Java PacketResult.IGNORED属性代码示例

@Override
public PacketResult receiveDataPacket(RawPacket inPkt) {
    if (inPkt == null) {
        return PacketResult.IGNORED;
    }
    logger.trace("Received a frame of size: {}",
                    inPkt.getPacketData().length);
    Packet formattedPak = this.dataPacketService.decodeDataPacket(inPkt);
    if (formattedPak instanceof Ethernet) {
        Object nextPak = formattedPak.getPayload();
        if (nextPak instanceof IPv4) {
            handlePuntedIPPacket((IPv4) nextPak, inPkt
                    .getIncomingNodeConnector());
            logger.trace("Handled IP packet");
        }
        if (nextPak instanceof ARP) {
            handleARPPacket((Ethernet) formattedPak, (ARP) nextPak, inPkt
                    .getIncomingNodeConnector());
            logger.trace("Handled ARP packet");
        }
    }
    return PacketResult.IGNORED;
}
 

@Override
public PacketResult receiveDataPacket(RawPacket inPkt) {
    log.trace("Received data packet.");

    // Convert packet to JSON representation.
    String jsonStr = pktToJSON(inPkt).toString();
            
    // Send notification to JMS topic.
    TextMessage message;
    try {
        if (session != null && publisher != null) {
            message = session.createTextMessage(jsonStr);
            setMsgProperties(message, inPkt);
            log.trace("Publishing the following packet-in event: " + jsonStr);
            publisher.send(message);
        } else {
            log.error("Cannot publish packet-in event. JMS not setup.");
        }
    } catch (JMSException e) {
        log.error("Error while publishing packet-in event: " + e.getMessage());
        return PacketResult.IGNORED;
    }
    
    // Also let other message handlers process this packet. 
    // If you don't want these services, remove them from
    // the OpenDaylight configuration.
    return PacketResult.KEEP_PROCESSING;
}
 

public PacketResult receiveDataPacket(RawPacket inPkt) {
    PacketResult result = PacketResult.IGNORED;

    // Let's only do this for OF nodeTypes... IOFMessageListener only understand OF
    if(packetInListeners.size() > 0 &&
        inPkt.getIncomingNodeConnector().getNode().getType() == Node.NodeIDType.OPENFLOW) {
        /*
         * Looked in org.sdnplatform.devicemanager.internal.DeviceManagerImpl.processPacketInMessage()
         * and it appears to only need the OFPacketIn.data and OFPacketIn.inport
         * additionally it seems to only need IOFSwitch.getID() and IOFSwitch.getStringID()
         */
        // Create a new OFPacketIn
        OFPacketIn in = new OFPacketIn();
        // Set its data
        in.setPacketData(inPkt.getPacketData());
        // Set its inport
        in.setInPort(toOFPort(inPkt.getIncomingNodeConnector()));

        // Create a new Ethernet and deserialize the packet data into it
        Ethernet eth = new Ethernet();
        eth.deserialize(in.getPacketData(), 0,
        in.getPacketData().length);
        // Add the Ethernet to the ListenerContext
        ListenerContext ctx = new ListenerContext();
        ctx.getStorage().put(IControllerService.CONTEXT_PI_PAYLOAD, eth);

        // Create a new OFSwitchAdaptor and set its id

        OFSwitchAdaptor sw = new OFSwitchAdaptor();
        sw.setId((Long) inPkt.getIncomingNodeConnector().getNode().getID());

        // Send OFPacketIn to all IOFMessageListeners
        for(IOFMessageListener packetInListener: this.packetInListeners) {
            packetInListener.receive(sw, in, ctx);
        }
        result = PacketResult.KEEP_PROCESSING;
    }

    return result;
}
 

@Override
public PacketResult receiveDataPacket(RawPacket inPkt) {
    if (inPkt.getIncomingNodeConnector() == null) {
        increaseStat("nullIncomingNodeConnector");
        return PacketResult.IGNORED;
    }

    // send the packet off to be processed by listeners
    this.dispatchPacket(inPkt);

    // Walk the chain of listener going first throw all the
    // parallel ones and for each parallel in serial
    return PacketResult.IGNORED;
}
 

@Override
public PacketResult receiveDataPacket(RawPacket inPkt) {
    if (inPkt == null) {
        logger.debug("Ignoring null packet");
        return PacketResult.IGNORED;
    }

    byte[] data = inPkt.getPacketData();
    if (data.length <= 0) {
        logger.trace("Ignoring zero length packet");
        return PacketResult.IGNORED;
    }

    if (!inPkt.getEncap().equals(LinkEncap.ETHERNET)) {
        logger.trace("Ignoring non ethernet packet");
        return PacketResult.IGNORED;
    }

    NodeConnector nodeConnector = inPkt.getIncomingNodeConnector();
    if (((Short) nodeConnector.getID()).equals(NodeConnector.SPECIALNODECONNECTORID)) {
        logger.trace("Ignoring ethernet packet received on special port: "
                + inPkt.getIncomingNodeConnector().toString());
        return PacketResult.IGNORED;
    }

    if (!connectionOutService.isLocal(nodeConnector.getNode())) {
        logger.debug("Discoery packets will not be processed from {} in a non-master controller", nodeConnector.toString());
        return PacketResult.IGNORED;
    }

    Ethernet ethPkt = new Ethernet();
    try {
        ethPkt.deserialize(data, 0, data.length * NetUtils.NumBitsInAByte);
    } catch (Exception e) {
        logger.warn("Failed to decode LLDP packet from {}: {}", inPkt.getIncomingNodeConnector(), e);
        return PacketResult.IGNORED;
    }

    if (ethPkt.getPayload() instanceof LLDP) {
        NodeConnector dst = inPkt.getIncomingNodeConnector();
        if (isEnabled(dst)) {
            if (!processDiscoveryPacket(dst, ethPkt)) {
                // Snoop the discovery pkt if not generated from us
                snoopDiscoveryPacket(dst, ethPkt);
            }
            return PacketResult.CONSUME;
        }
    }
    return PacketResult.IGNORED;
}