Java PacketContext类代码示例

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
@Override
public void process(PacketContext context) {
    if (context == null || context.isHandled()) {
        return;
    }

    Ethernet eth = context.inPacket().parsed();
    if (eth == null || (eth.getEtherType() != TYPE_LLDP && eth.getEtherType() != TYPE_BSN)) {
        return;
    }

    LinkDiscovery ld = discoverers.get(context.inPacket().receivedFrom().deviceId());
    if (ld == null) {
        return;
    }

    if (ld.handleLldp(context)) {
        context.block();
    }
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
LinkKey extractLinkKey(PacketContext packetContext) {
    Ethernet eth = packetContext.inPacket().parsed();
    if (eth == null) {
        return null;
    }

    ONOSLLDP onoslldp = ONOSLLDP.parseONOSLLDP(eth);
    if (onoslldp != null) {
        PortNumber srcPort = portNumber(onoslldp.getPort());
        PortNumber dstPort = packetContext.inPacket().receivedFrom().port();
        DeviceId srcDeviceId = DeviceId.deviceId(onoslldp.getDeviceString());
        DeviceId dstDeviceId = packetContext.inPacket().receivedFrom().deviceId();

        ConnectPoint src = new ConnectPoint(srcDeviceId, srcPort);
        ConnectPoint dst = new ConnectPoint(dstDeviceId, dstPort);
        return LinkKey.linkKey(src, dst);
    }
    return null;
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
/**
 * Tests discovery of a link that is not expected in the configuration.
 */
@Test
public void testNotConfiguredLink() {
    PacketContext pktCtx = new TestPacketContext(src, dst);

    testProcessor.process(pktCtx);

    assertThat(providerService.discoveredLinks().entrySet(), hasSize(1));
    DeviceId destination = providerService.discoveredLinks().get(dev1.id());
    assertThat(destination, notNullValue());
    LinkKey key = LinkKey.linkKey(src, dst);
    LinkDescription linkDescription = providerService
            .discoveredLinkDescriptions().get(key);
    assertThat(linkDescription, notNullValue());
    assertThat(linkDescription.isExpected(), is(false));
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
/**
 * Tests discovery of an expected link.
 */
@Test
public void testConfiguredLink() {
    LinkKey key = LinkKey.linkKey(src, dst);
    configListener.event(new NetworkConfigEvent(NetworkConfigEvent.Type.CONFIG_ADDED,
                                                key,
                                                BasicLinkConfig.class));

    PacketContext pktCtx = new TestPacketContext(src, dst);

    testProcessor.process(pktCtx);

    assertThat(providerService.discoveredLinks().entrySet(), hasSize(1));
    DeviceId destination = providerService.discoveredLinks().get(dev1.id());
    assertThat(destination, notNullValue());
    LinkDescription linkDescription = providerService
            .discoveredLinkDescriptions().get(key);
    assertThat(linkDescription, notNullValue());
    assertThat(linkDescription.isExpected(), is(true));
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
@Override
public void handlePacketIn(Bmv2Device device, int inputPort, ImmutableByteSequence packet) {
    Ethernet ethPkt = new Ethernet();
    ethPkt.deserialize(packet.asArray(), 0, packet.size());

    DeviceId deviceId = device.asDeviceId();
    ConnectPoint receivedFrom = new ConnectPoint(deviceId, PortNumber.portNumber(inputPort));

    ByteBuffer rawData = ByteBuffer.wrap(packet.asArray());

    InboundPacket inPkt = new DefaultInboundPacket(receivedFrom, ethPkt, rawData);
    OutboundPacket outPkt = new DefaultOutboundPacket(deviceId, null, rawData);

    PacketContext pktCtx = new Bmv2PacketContext(System.currentTimeMillis(), inPkt, outPkt, false);

    providerService.processPacket(pktCtx);
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
/**
 * Forward the packet to it's multicast destinations.
 *
 * @param context The packet context
 * @param egressList The list of egress ports which the multicast packet is intended for.
 */
private void forwardPacketToDst(PacketContext context, ArrayList<ConnectPoint> egressList) {

    // Send the pack out each of the respective egress ports
    for (ConnectPoint egress : egressList) {
        TrafficTreatment treatment = DefaultTrafficTreatment.builder()
                .setOutput(egress.port()).build();

        OutboundPacket packet = new DefaultOutboundPacket(
                egress.deviceId(),
                treatment,
                context.inPacket().unparsed());

        packetService.emit(packet);
    }
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
@Override
public void process(PacketContext context) {
    // Stop processing if the packet has been handled, since we
    // can't do any more to it.
    if (context.isHandled()) {
        return;
    }

    Ethernet packet = context.inPacket().parsed();

    if (packet == null) {
        return;
    }

    if (packet.getEtherType() == Ethernet.TYPE_IPV4) {
        IPv4 ipv4Packet = (IPv4) packet.getPayload();
        if (ipv4Packet.getProtocol() == IPv4.PROTOCOL_TCP) {
            TCP tcpPacket = (TCP) ipv4Packet.getPayload();

            if (tcpPacket.getDestinationPort() == BGP_PORT ||
                    tcpPacket.getSourcePort() == BGP_PORT) {
                forward(context);
            }
        }
    }
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
@Override
public void process(PacketContext context) {
    // Stop processing if the packet has been handled, since we
    // can't do any more to it.

    if (context.isHandled()) {
        return;
    }

    Ethernet packet = context.inPacket().parsed();

    if (packet == null) {
        return;
    }

    if (packet.getEtherType() == Ethernet.TYPE_IPV4) {
        IPv4 ipv4Packet = (IPv4) packet.getPayload();
        if (ipv4Packet.getProtocol() == IPv4.PROTOCOL_ICMP) {
            processPacketIn(context.inPacket());
        }
    }
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
/**
 * Processes the ARP Payload and initiates a reply to the client.
 *
 * @param context context of the incoming message
 * @param packet the ethernet payload
 */
private void processArpPacket(PacketContext context, Ethernet packet) {

    ARP arpPacket = (ARP) packet.getPayload();

    ARP arpReply = (ARP) arpPacket.clone();
    arpReply.setOpCode(ARP.OP_REPLY);

    arpReply.setTargetProtocolAddress(arpPacket.getSenderProtocolAddress());
    arpReply.setTargetHardwareAddress(arpPacket.getSenderHardwareAddress());
    arpReply.setSenderProtocolAddress(arpPacket.getTargetProtocolAddress());
    arpReply.setSenderHardwareAddress(myMAC.toBytes());

    // Ethernet Frame.
    Ethernet ethReply = new Ethernet();
    ethReply.setSourceMACAddress(myMAC);
    ethReply.setDestinationMACAddress(packet.getSourceMAC());
    ethReply.setEtherType(Ethernet.TYPE_ARP);
    ethReply.setVlanID(packet.getVlanID());

    ethReply.setPayload(arpReply);
    sendReply(context, ethReply);
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
/**
 * Integrates hosts learned through DHCP into topology.
 * @param context context of the incoming message
 * @param ipAssigned IP Address assigned to the host by DHCP Manager
 */
private void discoverHost(PacketContext context, Ip4Address ipAssigned) {
    if (!allowHostDiscovery) {
        // host discovery is not allowed, do nothing
        return;
    }

    Ethernet packet = context.inPacket().parsed();
    MacAddress mac = packet.getSourceMAC();
    VlanId vlanId = VlanId.vlanId(packet.getVlanID());
    HostLocation hostLocation = new HostLocation(context.inPacket().receivedFrom(), 0);

    Set<IpAddress> ips = new HashSet<>();
    ips.add(ipAssigned);

    HostId hostId = HostId.hostId(mac, vlanId);
    DefaultHostDescription desc = new DefaultHostDescription(mac, vlanId, hostLocation, ips);

    log.info("Discovered host {}", desc);
    hostProviderService.hostDetected(hostId, desc, false);
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
@Override
public void process(PacketContext context) {

    if (context.isHandled()) {
        return;
    }

    InboundPacket pkt = context.inPacket();
    Ethernet ethernet = pkt.parsed();
    log.trace("Rcvd pktin: {}", ethernet);
    if (ethernet.getEtherType() == Ethernet.TYPE_ARP) {
        arpHandler.processPacketIn(pkt);
    } else if (ethernet.getEtherType() == Ethernet.TYPE_IPV4) {
        IPv4 ipPacket = (IPv4) ethernet.getPayload();
        ipHandler.addToPacketBuffer(ipPacket);
        if (ipPacket.getProtocol() == IPv4.PROTOCOL_ICMP) {
            icmpHandler.processPacketIn(pkt);
        } else {
            ipHandler.processPacketIn(pkt);
        }
    }
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
@Override
public void process(PacketContext context) {
    if (context.isHandled()) {
        return;
    }

    Ethernet ethPacket = context.inPacket().parsed();
    if (ethPacket == null || ethPacket.getEtherType() != Ethernet.TYPE_IPV4) {
        return;
    }
    IPv4 ipv4Packet = (IPv4) ethPacket.getPayload();
    if (ipv4Packet.getProtocol() != IPv4.PROTOCOL_UDP) {
        return;
    }
    UDP udpPacket = (UDP) ipv4Packet.getPayload();
    if (udpPacket.getDestinationPort() != UDP.DHCP_SERVER_PORT ||
            udpPacket.getSourcePort() != UDP.DHCP_CLIENT_PORT) {
        return;
    }

    DHCP dhcpPacket = (DHCP) udpPacket.getPayload();
    processDhcp(context, dhcpPacket);
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
private void sendReply(PacketContext context, Ethernet ethReply) {
    if (ethReply == null) {
        return;
    }
    ConnectPoint srcPoint = context.inPacket().receivedFrom();
    TrafficTreatment treatment = DefaultTrafficTreatment
            .builder()
            .setOutput(srcPoint.port())
            .build();

    packetService.emit(new DefaultOutboundPacket(
            srcPoint.deviceId(),
            treatment,
            ByteBuffer.wrap(ethReply.serialize())));
    context.block();
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
@Override
public void process(PacketContext context) {
    if (context.isHandled()) {
        return;
    }
    Ethernet ethPacket = context.inPacket().parsed();
    if (ethPacket == null || ethPacket.getEtherType() != Ethernet.TYPE_ARP) {
        return;
    }

    ARP arpPacket = (ARP) ethPacket.getPayload();
    switch (arpPacket.getOpCode()) {
        case ARP.OP_REQUEST:
            processArpRequest(context, ethPacket);
            break;
        case ARP.OP_REPLY:
            processArpReply(context, ethPacket);
            break;
        default:
            break;
    }
}
 

import org.onosproject.net.packet.PacketContext; //导入依赖的package包/类
@Override
public void process(PacketContext context) {
	if (context.isHandled()) {
		return;
	}
	InboundPacket pkt = context.inPacket();
	Ethernet ethPkt = pkt.parsed();

	if (ethPkt == null) {
		return;
	}

	if (ethPkt.getEtherType() == EtherType.ARP.ethType().toShort()) {
		context.treatmentBuilder().setOutput(PortNumber.FLOOD);
		context.send();
	}
}