Java PacketContext.block方法代码示例

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包/类
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包/类
private boolean handleNdp(PacketContext context, Ethernet ethPkt) {
    IPv6 ipv6 = (IPv6) ethPkt.getPayload();

    if (ipv6.getNextHeader() != IPv6.PROTOCOL_ICMP6) {
        return false;
    }
    ICMP6 icmpv6 = (ICMP6) ipv6.getPayload();
    if (icmpv6.getIcmpType() == ICMP6.NEIGHBOR_ADVERTISEMENT) {
        forward(ethPkt, context.inPacket().receivedFrom());
    } else if (icmpv6.getIcmpType() == ICMP6.NEIGHBOR_SOLICITATION) {
        reply(ethPkt, context.inPacket().receivedFrom());
    } else {
        return false;
    }
    context.block();
    return true;
}
 

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

    if (interfaceService.getInterfacesByPort(context.inPacket().receivedFrom()).isEmpty()) {
        // Don't handle packets that don't come from one of our configured interfaces
        return;
    }

    Ethernet eth = context.inPacket().parsed();
    if (eth == null) {
        return;
    }

    if (!handle(eth)) {
        return;
    }

    context.block();
}
 

import org.onosproject.net.packet.PacketContext; //导入方法依赖的package包/类
private void handlePacket(PacketContext context) {
    InboundPacket pkt = context.inPacket();
    Ethernet ethPkt = pkt.parsed();

    NeighbourMessageContext msgContext =
            DefaultNeighbourMessageContext.createContext(ethPkt, pkt.receivedFrom(), actions);

    if (msgContext == null) {
        return;
    }

    if (handleMessage(msgContext)) {
        context.block();
    }

}
 

import org.onosproject.net.packet.PacketContext; //导入方法依赖的package包/类
private void flood(PacketContext context) {
    if (topologyService.isBroadcastPoint(topologyService.currentTopology(),
            context.inPacket().receivedFrom())) {
        packetOut(context, PortNumber.FLOOD);
    } else {
        context.block();
    }
}
 

import org.onosproject.net.packet.PacketContext; //导入方法依赖的package包/类
/**
 * Sends the Ethernet reply frame via the Packet Service.
 *
 * @param context the context of the incoming frame
 * @param reply the Ethernet reply frame
 */
private void sendReply(PacketContext context, Ethernet reply) {
    if (reply != null) {
        TrafficTreatment.Builder builder = DefaultTrafficTreatment.builder();
        ConnectPoint sourcePoint = context.inPacket().receivedFrom();
        builder.setOutput(sourcePoint.port());
        context.block();
        packetService.emit(new DefaultOutboundPacket(sourcePoint.deviceId(),
                builder.build(), ByteBuffer.wrap(reply.serialize())));
    }
}
 

import org.onosproject.net.packet.PacketContext; //导入方法依赖的package包/类
private void flood(PacketContext context) {
    if (topologyService.isBroadcastPoint(topologyService.currentTopology(),
                                         context.inPacket().receivedFrom())) {
        packetOut(context, PortNumber.FLOOD);
    } else {
        context.block();
    }
}
 

import org.onosproject.net.packet.PacketContext; //导入方法依赖的package包/类
@Override
public boolean handlePacket(PacketContext context) {
    checkPermission(PACKET_WRITE);

    InboundPacket pkt = context.inPacket();
    Ethernet ethPkt = pkt.parsed();

    if (ethPkt == null) {
        return false;
    }

    MessageContext msgContext = createContext(ethPkt, pkt.receivedFrom());

    if (msgContext == null) {
        return false;
    }

    switch (msgContext.type()) {
    case REPLY:
        forward(msgContext.packet(), msgContext.inPort());
        break;
    case REQUEST:
        replyInternal(msgContext);
        break;
    default:
        return false;
    }

    context.block();
    return true;
}
 

import org.onosproject.net.packet.PacketContext; //导入方法依赖的package包/类
/**
 * Emits ARP reply with fake MAC address for a given ARP request.
 * It only handles requests for the registered gateway IPs and host IPs.
 *
 * @param context packet context
 * @param ethPacket ethernet packet
 */
private void processArpRequest(PacketContext context, Ethernet ethPacket) {
    ARP arpPacket = (ARP) ethPacket.getPayload();
    Ip4Address targetIp = Ip4Address.valueOf(arpPacket.getTargetProtocolAddress());

    MacAddress gatewayMac = gateways.get(targetIp);
    MacAddress replyMac = gatewayMac != null ? gatewayMac :
            getMacFromHostService(targetIp);

    if (replyMac.equals(MacAddress.NONE)) {
        forwardArpRequest(context, ethPacket);
        return;
    }

    Ethernet ethReply = ARP.buildArpReply(
            targetIp,
            replyMac,
            ethPacket);

    TrafficTreatment treatment = DefaultTrafficTreatment.builder()
            .setOutput(context.inPacket().receivedFrom().port())
            .build();

    packetService.emit(new DefaultOutboundPacket(
            context.inPacket().receivedFrom().deviceId(),
            treatment,
            ByteBuffer.wrap(ethReply.serialize())));

    context.block();
}
 

import org.onosproject.net.packet.PacketContext; //导入方法依赖的package包/类
private void processArpReply(PacketContext context, Ethernet ethPacket) {
    ARP arpPacket = (ARP) ethPacket.getPayload();
    Ip4Address targetIp = Ip4Address.valueOf(arpPacket.getTargetProtocolAddress());

    DeviceId deviceId = context.inPacket().receivedFrom().deviceId();
    Host host = hostService.getHostsByIp(targetIp).stream()
            .filter(h -> h.location().deviceId().equals(deviceId))
            .findFirst()
            .orElse(null);

    if (host == null) {
        // do nothing for the unknown ARP reply
        log.trace("No host found for {} in {}", targetIp, deviceId);
        context.block();
        return;
    }

    TrafficTreatment treatment = DefaultTrafficTreatment.builder()
            .setOutput(host.location().port())
            .build();

    packetService.emit(new DefaultOutboundPacket(
            deviceId,
            treatment,
            ByteBuffer.wrap(ethPacket.serialize())));

    context.block();
}
 

import org.onosproject.net.packet.PacketContext; //导入方法依赖的package包/类
private void forwardArpRequest(PacketContext context, Ethernet ethPacket) {
    DeviceId deviceId = context.inPacket().receivedFrom().deviceId();
    PortNumber inputPort = context.inPacket().receivedFrom().port();

    Host host = hostService.getHost(HostId.hostId(ethPacket.getSourceMAC()));
    NetworkType networkType = Instance.of(host).netType();
    if (host == null || (networkType != MANAGEMENT_HOST &&
            networkType != FLAT)) {
        context.block();
        log.trace("Failed to handle ARP request");
        return;
    }

    PortNumber outputPort = networkType == MANAGEMENT_HOST ?
            hostMgmtPort(deviceId) : dataPort(deviceId);
    if (inputPort.equals(outputPort)) {
        context.block();
        return;
    }

    if (outputPort != null) {
        TrafficTreatment treatment = DefaultTrafficTreatment.builder()
                .setOutput(outputPort)
                .build();

        packetService.emit(new DefaultOutboundPacket(
                context.inPacket().receivedFrom().deviceId(),
                treatment,
                ByteBuffer.wrap(ethPacket.serialize())));
    } else {
        log.trace("Failed to handle ARP request");
    }

    context.block();
}
 

import org.onosproject.net.packet.PacketContext; //导入方法依赖的package包/类
@Override
public void process(PacketContext context) {
    if (context == null) {
        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包/类
private boolean handleArp(PacketContext context, Ethernet ethPkt) {
    ARP arp = (ARP) ethPkt.getPayload();

    if (arp.getOpCode() == ARP.OP_REPLY) {
        forward(ethPkt, context.inPacket().receivedFrom());
    } else if (arp.getOpCode() == ARP.OP_REQUEST) {
        reply(ethPkt, context.inPacket().receivedFrom());
    } else {
        return false;
    }
    context.block();
    return true;
}
 

import org.onosproject.net.packet.PacketContext; //导入方法依赖的package包/类
private void processArpPacket(PacketContext context, Ethernet ethernet) {
    ARP arp = (ARP) ethernet.getPayload();
    if (arp.getOpCode() != ARP.OP_REQUEST) {
        return;
    }

    if (log.isTraceEnabled()) {
        log.trace("ARP request received from {} for {}",
                Ip4Address.valueOf(arp.getSenderProtocolAddress()).toString(),
                Ip4Address.valueOf(arp.getTargetProtocolAddress()).toString());
    }

    IpAddress targetIp = Ip4Address.valueOf(arp.getTargetProtocolAddress());
    if (!isServiceIp(targetIp.getIp4Address())) {
        log.trace("Unknown target ARP request for {}, ignore it", targetIp);
        return;
    }

    MacAddress targetMac = Constants.DEFAULT_EXTERNAL_ROUTER_MAC;
    Ethernet ethReply = ARP.buildArpReply(targetIp.getIp4Address(),
            targetMac, ethernet);

    TrafficTreatment treatment = DefaultTrafficTreatment.builder()
            .setOutput(context.inPacket().receivedFrom().port())
            .build();

    packetService.emit(new DefaultOutboundPacket(
            context.inPacket().receivedFrom().deviceId(),
            treatment,
            ByteBuffer.wrap(ethReply.serialize())));

    context.block();
}