Java IPv4.getDestinationAddress方法代码示例

import net.floodlightcontroller.packet.IPv4; //导入方法依赖的package包/类
@Override
public int getDstIP(FPContext cntx) {
	FloodlightContext flCntx = cntx.getFlowContext();
	
	Ethernet eth = IFloodlightProviderService.bcStore.get(flCntx,IFloodlightProviderService.CONTEXT_PI_PAYLOAD);
	IPv4Address dstIP;
	
	if(eth.getEtherType() == EthType.IPv4)
	{		
		IPv4 ipv4 = (IPv4) eth.getPayload();
		dstIP = ipv4.getDestinationAddress();
		return dstIP.getInt();
	}
	else if (eth.getEtherType() == EthType.ARP){
		ARP arp = (ARP) eth.getPayload();

		dstIP = arp.getTargetProtocolAddress();

		return dstIP.getInt();
	}
	
	//for other packets without destination IP information
	return 0;
	
}
 

import net.floodlightcontroller.packet.IPv4; //导入方法依赖的package包/类
/**
 * Get a (partial) entity for the destination from the packet.
 * @param eth
 * @return
 */
protected Entity getDestEntityFromPacket(Ethernet eth) {
	MacAddress dlAddr = eth.getDestinationMACAddress();
	VlanVid vlan = VlanVid.ofVlan(eth.getVlanID());
	IPv4Address nwDst = IPv4Address.NONE;

	// Ignore broadcast/multicast destination
	if (dlAddr.isBroadcast() || dlAddr.isMulticast())
		return null;
	// Ignore zero dest mac
	if (dlAddr.getLong() == 0)
		return null;

	if (eth.getPayload() instanceof IPv4) {
		IPv4 ipv4 = (IPv4) eth.getPayload();
		nwDst = ipv4.getDestinationAddress();
	}
	
	return new Entity(dlAddr,
			vlan,
			nwDst,
			null,
			null,
			null);
}
 

import net.floodlightcontroller.packet.IPv4; //导入方法依赖的package包/类
/**
 * Get a (partial) entity for the destination from the packet.
 * @param eth
 * @return
 */
protected Entity getDestEntityFromPacket(Ethernet eth) {
    byte[] dlAddrArr = eth.getDestinationMACAddress();
    long dlAddr = Ethernet.toLong(dlAddrArr);
    short vlan = eth.getVlanID();
    int nwDst = 0;

    // Ignore broadcast/multicast destination
    if ((dlAddrArr[0] & 0x1) != 0)
        return null;
    // Ignore zero dest mac
    if (dlAddr == 0)
        return null;

    if (eth.getPayload() instanceof IPv4) {
        IPv4 ipv4 = (IPv4) eth.getPayload();
        nwDst = ipv4.getDestinationAddress();
    }

    return new Entity(dlAddr,
                      ((vlan >= 0) ? vlan : null),
                      ((nwDst != 0) ? nwDst : null),
                      null,
                      null,
                      null);
}
 

import net.floodlightcontroller.packet.IPv4; //导入方法依赖的package包/类
/**
 * Get a (partial) entity for the destination from the packet.
 * @param eth
 * @return
 */
protected Entity getDestEntityFromPacket(Ethernet eth) {
	MacAddress dlAddr = eth.getDestinationMACAddress();
	VlanVid vlan = VlanVid.ofVlan(eth.getVlanID());
	IPv4Address ipv4Dst = IPv4Address.NONE;
	IPv6Address ipv6Dst = IPv6Address.NONE;

	// Ignore broadcast/multicast destination
	if (dlAddr.isBroadcast() || dlAddr.isMulticast())
		return null;
	// Ignore zero dest mac
	if (dlAddr.equals(MacAddress.of(0)))
		return null;

	if (eth.getPayload() instanceof IPv4) {
		IPv4 ipv4 = (IPv4) eth.getPayload();
		ipv4Dst = ipv4.getDestinationAddress();
	} else if (eth.getPayload() instanceof IPv6) {
		IPv6 ipv6 = (IPv6) eth.getPayload();
		ipv6Dst = ipv6.getDestinationAddress();
	}
	
	return new Entity(dlAddr,
			vlan,
			ipv4Dst,
			ipv6Dst,
			DatapathId.NONE,
			OFPort.ZERO,
			Entity.NO_DATE);
}
 

import net.floodlightcontroller.packet.IPv4; //导入方法依赖的package包/类
/**
 * Get a (partial) entity for the destination from the packet.
 * @param eth
 * @return
 */
protected Entity getDestEntityFromPacket(Ethernet eth) {
	MacAddress dlAddr = eth.getDestinationMACAddress();
	VlanVid vlan = VlanVid.ofVlan(eth.getVlanID());
	IPv4Address ipv4Dst = IPv4Address.NONE;
	IPv6Address ipv6Dst = IPv6Address.NONE;

	// Ignore broadcast/multicast destination
	if (dlAddr.isBroadcast() || dlAddr.isMulticast())
		return null;
	// Ignore zero dest mac
	if (dlAddr.equals(MacAddress.of(0)))
		return null;

	if (eth.getPayload() instanceof IPv4) {
		IPv4 ipv4 = (IPv4) eth.getPayload();
		ipv4Dst = ipv4.getDestinationAddress();
	} else if (eth.getPayload() instanceof IPv6) {
		IPv6 ipv6 = (IPv6) eth.getPayload();
		ipv6Dst = ipv6.getDestinationAddress();
	}

	return new Entity(dlAddr,
			vlan,
			ipv4Dst,
			ipv6Dst,
			DatapathId.NONE,
			OFPort.ZERO,
			Entity.NO_DATE);
}
 

import net.floodlightcontroller.packet.IPv4; //导入方法依赖的package包/类
/**
 * Instead of using the Firewall's routing decision Match, which might be as general
 * as "in_port" and inadvertently Match packets erroneously, construct a more
 * specific Match based on the deserialized OFPacketIn's payload, which has been 
 * placed in the FloodlightContext already by the Controller.
 * 
 * @param sw, the switch on which the packet was received
 * @param inPort, the ingress switch port on which the packet was received
 * @param cntx, the current context which contains the deserialized packet
 * @return a composed Match object based on the provided information
 */
protected Match createMatchFromPacket(IOFSwitch sw, OFPort inPort, FloodlightContext cntx) {
	// The packet in match will only contain the port number.
	// We need to add in specifics for the hosts we're routing between.
	Ethernet eth = IFloodlightProviderService.bcStore.get(cntx, IFloodlightProviderService.CONTEXT_PI_PAYLOAD);
	VlanVid vlan = VlanVid.ofVlan(eth.getVlanID());
	MacAddress srcMac = eth.getSourceMACAddress();
	MacAddress dstMac = eth.getDestinationMACAddress();

	// A retentive builder will remember all MatchFields of the parent the builder was generated from
	// With a normal builder, all parent MatchFields will be lost if any MatchFields are added, mod, del
	// TODO (This is a bug in Loxigen and the retentive builder is a workaround.)
	Match.Builder mb = sw.getOFFactory().buildMatch();
	mb.setExact(MatchField.IN_PORT, inPort)
	.setExact(MatchField.ETH_SRC, srcMac)
	.setExact(MatchField.ETH_DST, dstMac);

	if (!vlan.equals(VlanVid.ZERO)) {
		mb.setExact(MatchField.VLAN_VID, OFVlanVidMatch.ofVlanVid(vlan));
	}

	// TODO Detect switch type and match to create hardware-implemented flow
	// TODO Set option in config file to support specific or MAC-only matches
	if (eth.getEtherType() == EthType.IPv4) { /* shallow check for equality is okay for EthType */
		IPv4 ip = (IPv4) eth.getPayload();
		IPv4Address srcIp = ip.getSourceAddress();
		IPv4Address dstIp = ip.getDestinationAddress();
		mb.setExact(MatchField.IPV4_SRC, srcIp)
		.setExact(MatchField.IPV4_DST, dstIp)
		.setExact(MatchField.ETH_TYPE, EthType.IPv4);

		if (ip.getProtocol().equals(IpProtocol.TCP)) {
			TCP tcp = (TCP) ip.getPayload();
			mb.setExact(MatchField.IP_PROTO, IpProtocol.TCP)
			.setExact(MatchField.TCP_SRC, tcp.getSourcePort())
			.setExact(MatchField.TCP_DST, tcp.getDestinationPort());
		} else if (ip.getProtocol().equals(IpProtocol.UDP)) {
			UDP udp = (UDP) ip.getPayload();
			mb.setExact(MatchField.IP_PROTO, IpProtocol.UDP)
			.setExact(MatchField.UDP_SRC, udp.getSourcePort())
			.setExact(MatchField.UDP_DST, udp.getDestinationPort());
		}	
	} else if (eth.getEtherType() == EthType.ARP) { /* shallow check for equality is okay for EthType */
		mb.setExact(MatchField.ETH_TYPE, EthType.ARP);
	}
	return mb.build();
}
 

import net.floodlightcontroller.packet.IPv4; //导入方法依赖的package包/类
private net.floodlightcontroller.core.IListener.Command
        processPacketIn(IOFSwitch sw, OFPacketIn pi,
                        FloodlightContext cntx) {
    
    Ethernet eth = IFloodlightProviderService.bcStore.get(cntx,
                                                          IFloodlightProviderService.CONTEXT_PI_PAYLOAD);
    IPacket pkt = eth.getPayload();
 
    if (eth.isBroadcast() || eth.isMulticast()) {
        // handle ARP for VIP
        if (pkt instanceof ARP) {
            // retrieve arp to determine target IP address                                                       
            ARP arpRequest = (ARP) eth.getPayload();

            int targetProtocolAddress = IPv4.toIPv4Address(arpRequest
                                                           .getTargetProtocolAddress());

            if (vipIpToId.containsKey(targetProtocolAddress)) {
                String vipId = vipIpToId.get(targetProtocolAddress);
                vipProxyArpReply(sw, pi, cntx, vipId);
                return Command.STOP;
            }
        }
    } else {
        // currently only load balance IPv4 packets - no-op for other traffic 
        if (pkt instanceof IPv4) {
            IPv4 ip_pkt = (IPv4) pkt;
            
            // If match Vip and port, check pool and choose member
            int destIpAddress = ip_pkt.getDestinationAddress();
            
            if (vipIpToId.containsKey(destIpAddress)){
                IPClient client = new IPClient();
                client.ipAddress = ip_pkt.getSourceAddress();
                client.nw_proto = ip_pkt.getProtocol();
                if (ip_pkt.getPayload() instanceof TCP) {
                    TCP tcp_pkt = (TCP) ip_pkt.getPayload();
                    client.srcPort = tcp_pkt.getSourcePort();
                    client.targetPort = tcp_pkt.getDestinationPort();
                }
                if (ip_pkt.getPayload() instanceof UDP) {
                    UDP udp_pkt = (UDP) ip_pkt.getPayload();
                    client.srcPort = udp_pkt.getSourcePort();
                    client.targetPort = udp_pkt.getDestinationPort();
                }
                if (ip_pkt.getPayload() instanceof ICMP) {
                    client.srcPort = 8; 
                    client.targetPort = 0; 
                }
                
                LBVip vip = vips.get(vipIpToId.get(destIpAddress));
                LBPool pool = pools.get(vip.pickPool(client));
                LBMember member = members.get(pool.pickMember(client));

                // for chosen member, check device manager and find and push routes, in both directions                    
                pushBidirectionalVipRoutes(sw, pi, cntx, client, member);
               
                // packet out based on table rule
                pushPacket(pkt, sw, pi.getBufferId(), pi.getInPort(), OFPort.OFPP_TABLE.getValue(),
                            cntx, true);

                return Command.STOP;
            }
        }
    }
    // bypass non-load-balanced traffic for normal processing (forwarding)
    return Command.CONTINUE;
}