Java RawPacket.getIncomingNodeConnector方法代码示例

import org.opendaylight.controller.sal.packet.RawPacket; //导入方法依赖的package包/类
/**
 *The function is a modification of an another function. The original
 *is property of SDNHUB.org and it's used under a GPLv3 License. All the credits for SDNHUB.org
 *The original code can be find in
 *https://github.com/sdnhub/SDNHub_Opendaylight_Tutorial/blob/master/adsal_L2_forwarding/src/main/java/org/opendaylight/tutorial/tutorial_L2_forwarding/internal/TutorialL2Forwarding.java
 * Función utilizada para inundar en caso de no tener la dirección destino
 * @param inPkt: paquete entrante al nodo
 */
private void floodPacket(RawPacket inPkt) {
	log.info("flooding packet");
    NodeConnector incoming_connector = inPkt.getIncomingNodeConnector();
    Node incoming_node = incoming_connector.getNode();
    Set<NodeConnector> nodeConnectors = this.switchManager.getUpNodeConnectors(incoming_node);
    for (NodeConnector p : nodeConnectors) {
        if (!p.equals(incoming_connector)) {
            try {
                RawPacket destPkt = new RawPacket(inPkt);
                destPkt.setOutgoingNodeConnector(p);
                this.dataPacketService.transmitDataPacket(destPkt);
                //log.info("Datos de paquete transmitido dentro de floodpacket: "+this.dataPacketService.decodeDataPacket(destPkt).toString());
            } catch (ConstructionException e2) {
                continue;
            }
        }
    }
}
 

import org.opendaylight.controller.sal.packet.RawPacket; //导入方法依赖的package包/类
@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;
}
 

import org.opendaylight.controller.sal.packet.RawPacket; //导入方法依赖的package包/类
@Override
public PacketResult receiveDataPacket(RawPacket inPkt) {
	NodeConnector inport = inPkt.getIncomingNodeConnector();
	RawPacket outPkt = null;
	IPv4 ipv4 = new IPv4();
	ipv4.setDiffServ((byte) 4);
	outPkt = this.dataPacketService.encodeDataPacket(ipv4);
	outPkt.setOutgoingNodeConnector(inport);
	this.dataPacketService.transmitDataPacket(outPkt);
	// outPkt.setOutgoingNodeConnector(outgoingNodeConnector);
	return null;
}
 

import org.opendaylight.controller.sal.packet.RawPacket; //导入方法依赖的package包/类
/**
 * Converts a packet to JSON representation.
 * 
 * @param pkt the packet to be converted
 * @return JSON representation.
 */
private JSONObject pktToJSON(RawPacket rawPkt) {
    log.trace("Received packet-in event.");
    
    JSONObject json = new JSONObject();
    
    // Add incoming node
    
    // The connector, the packet came from ("port")
    NodeConnector ingressConnector = rawPkt.getIncomingNodeConnector();
    // The node that received the packet ("switch")
    Node node = ingressConnector.getNode();

    JSONObject nodeJson = new JSONObject();
    nodeJson.put(NodeAttributes.Keys.ID.toJSON(), node.getNodeIDString());
    nodeJson.put(NodeAttributes.Keys.TYPE.toJSON(), node.getType());
    json.put(PacketInAttributes.Keys.NODE.toJSON(), nodeJson);
    
    // Add inport
    
    json.put(PacketInAttributes.Keys.INGRESS_PORT.toJSON(), ingressConnector.getNodeConnectorIDString());
    
    // Add raw packet data
    
    // Use DataPacketService to decode the packet.
    Packet pkt = dataPacketService.decodeDataPacket(rawPkt);

    while (pkt != null) {
        if (pkt instanceof Ethernet) {
            Ethernet ethernet = (Ethernet) pkt;
            ethernetToJSON(ethernet, json);
        } else if(pkt instanceof IEEE8021Q) {
            IEEE8021Q ieee802q = (IEEE8021Q) pkt;
            ieee8021qToJSON(ieee802q, json);
        } else if (pkt instanceof IPv4) {
            IPv4 ipv4 = (IPv4) pkt;
            ipv4ToJSON(ipv4, json);
        } else if (pkt instanceof TCP) {
            TCP tcp = (TCP) pkt;
            tcpToJSON(tcp, json);
        } else if (pkt instanceof UDP) {
            UDP udp = (UDP) pkt;
            udpToJSON(udp, json);
        }
        
        pkt = pkt.getPayload();
    }
    
    json.put(PacketInAttributes.Keys.PACKET.toJSON(), DatatypeConverter.printBase64Binary(rawPkt.getPacketData()));
    
    return json;
}
 

import org.opendaylight.controller.sal.packet.RawPacket; //导入方法依赖的package包/类
@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;
}