org.pcap4j.packet.IpV4Packet Java Examples

private Packet fixL3L4Checksums(Packet packet) {
    Packet.Builder builder = packet.getBuilder();
    builder.get(IpV4Packet.Builder.class).correctChecksumAtBuild(true);

    TcpPacket.Builder tcpBuilder = builder.get(TcpPacket.Builder.class);
    if (tcpBuilder != null) {
        tcpBuilder.srcAddr(packet.get(IpV4Packet.class).getHeader().getSrcAddr());
        tcpBuilder.dstAddr(packet.get(IpV4Packet.class).getHeader().getDstAddr());
        tcpBuilder.correctChecksumAtBuild(true);
    }

    UdpPacket.Builder udpBuilder = builder.get(UdpPacket.Builder.class);
    if (udpBuilder != null) {
        udpBuilder.srcAddr(packet.get(IpV4Packet.class).getHeader().getSrcAddr());
        udpBuilder.dstAddr(packet.get(IpV4Packet.class).getHeader().getDstAddr());
        udpBuilder.correctChecksumAtBuild(true);
    }
    return builder.build();
}
 

IpV4Packet getIpV4Packet_pppoe(EthernetPacket packet_eth) throws IllegalRawDataException{
	IpV4Packet ipV4Packet=null;
	byte[] pppData=packet_eth.getPayload().getRawData();
	if(pppData.length>8&&pppData[8]==0x45){
		byte[] b2=new byte[2];
		System.arraycopy(pppData, 4, b2, 0, 2);
		short len=(short) ByteShortConvert.toShort(b2, 0);
		int ipLength=toUnsigned(len)-2;
		byte[] ipData=new byte[ipLength];
		//设置ppp参数
		PacketUtils.pppHead_static[2]=pppData[2];
		PacketUtils.pppHead_static[3]=pppData[3];
		if(ipLength==(pppData.length-8)){
			System.arraycopy(pppData, 8, ipData, 0, ipLength);
			ipV4Packet=IpV4Packet.newPacket(ipData, 0, ipData.length);
		}else {
			MLog.println("长度不符!");
		}
	}
	return ipV4Packet;
}
 

/**
 * Build IPV4 packet
 *
 * @param packetData
 * @return
 * @throws IOException
 * @throws InterruptedException
 * @throws PcapNativeException
 * @throws NotOpenException
 * @throws java.net.URISyntaxException
 */
public TrexEthernetPacket buildIPV4Packet(PacketData packetData) throws IOException, InterruptedException, PcapNativeException, NotOpenException, URISyntaxException {

    LOG.info("create ethernet packet");
    int packetLength = PacketBuilderHelper.getPacketLength(packetData.getPacketLength().getLengthType(), packetData.getPacketLength().getFrameLength(), packetData.getPacketLength().getMaxLength());
    Payload payload = packetUtil.getPayload(packetData.getPayload());
    TrexEthernetPacket ethernetPacket = packetUtil.prepareEthernetPacket(packetData, packetLength, payload);

    // define VLAN 
    IpV4Packet.Builder ipV4Packet = getIPV4PacketBuilder(PacketBuilderHelper.getIPV4TotalLength(packetData.isTaggedVlan()), packetLength, payload, packetData);
    if (!packetData.isTaggedVlan()) {
        LOG.info("Add IPV4 packet");
        ethernetPacket.buildPacket(ipV4Packet);
    } else {
        packetUtil.addVlanToPacket(ethernetPacket, ipV4Packet);
    }

    return ethernetPacket;
}
 

/**
 * Validate packet
 *
 * @param packet
 * @return
 */
public boolean validatePacket(Packet packet) {
    validPacket = true;
    if(packet.get(IpV4Packet.class) == null){
        validPacket = false;
    }else if (defaultSrcAddress == null) {
        return true;
    } else if (!packet.get(IpV4Packet.class).getHeader().getProtocol().name().equals(protocolType)) {
        validPacket = false;
    } else {
        // check src/dst port combination
        currentSrcAddressPort = packet.get(IpV4Packet.class).getHeader().getSrcAddr().getHostAddress() + ":" + getSrcPort(packet);
        currentDstAddressPort = packet.get(IpV4Packet.class).getHeader().getDstAddr().getHostAddress() + ":" + getDstPort(packet);
        if ((!currentSrcAddressPort.equals(defaultSrcAddressPort) && !currentSrcAddressPort.equals(defaultDstAddressPort))
                || (!currentDstAddressPort.equals(defaultSrcAddressPort) && !currentDstAddressPort.equals(defaultDstAddressPort))) {
            validPacket = false;
        }
    }
    return validPacket;
}
 

/**
 * Update source IP address
 */
private Packet updateSrcAddress(Packet packet) {
    try {
        if (importedProperties.isSourceEnabled()) {
            Inet4Address modifiedAddress = (Inet4Address) Inet4Address.getByAddress(convertIPToByte(importedProperties.getSrcAddress()));
            Packet.Builder builder = packet.getBuilder();
            if (packet.get(IpV4Packet.class).getHeader().getSrcAddr().getHostAddress().equals(defaultSrcAddress)) {
                builder.get(IpV4Packet.Builder.class).srcAddr(modifiedAddress);
            } else {
                builder.get(IpV4Packet.Builder.class).dstAddr(modifiedAddress);
            }
            packet = builder.build();
        }

    } catch (Exception ex) {
        LOG.error("Error updating source IP", ex);
    }
    return packet;
}
 

/**
 * Update destination IP address
 */
private Packet updateDstAddress(Packet packet) {
    try {
        if (importedProperties.isDestinationEnabled()) {
            Inet4Address modifiedAddress = (Inet4Address) Inet4Address.getByAddress(convertIPToByte(importedProperties.getDstAddress()));
            Packet.Builder builder = packet.getBuilder();
            if (packet.get(IpV4Packet.class).getHeader().getDstAddr().getHostAddress().equals(defaultDstAddress)) {
                builder.get(IpV4Packet.Builder.class).dstAddr(modifiedAddress);
            } else {
                builder.get(IpV4Packet.Builder.class).srcAddr(modifiedAddress);
            }
            packet = builder.build();
        }
    } catch (Exception ex) {
        LOG.error("Error updating destination IP", ex);
    }
    return packet;
}
 

/**
 *
 * @param builder
 * @param protocol
 */
public void buildPacket(AbstractPacket.AbstractBuilder builder, IpNumber protocol) {

    byte[] pad = new byte[1];
    String payloadPattern = payload.getPayloadPattern();
    String payloadString = payload.getPayloadType().getPadPayloadString(payloadPattern, (totalLength - 20) * 2);

    if (packetLength > DEFAULT_PACKET_LENGTH) {
        payloadString = payload.getPayloadType().getPadPayloadString(payloadPattern, payloadString.length() + ((packetLength - DEFAULT_PACKET_LENGTH) * 2));
        this.totalLength = (short) ((int) totalLength + (packetLength - DEFAULT_PACKET_LENGTH));
    }
    pad = payload.getPayloadPad(payloadString, totalLength - 20);

    ipV4Builder = new IpV4Packet.Builder();
    ipV4Builder.version(version)
            .ihl(ihl)
            .tos(tos)
            .totalLength(totalLength)
            .identification(identification)
            .reservedFlag(reservedFlag)
            .ttl(ttl)
            .fragmentOffset((short) 0)
            .protocol(protocol)
            .headerChecksum(headerChecksum)
            .srcAddr(srcAddr)
            .dstAddr(dstAddr)
            .protocol(protocol)
            .correctChecksumAtBuild(true)
            //  .correctLengthAtBuild(true)
            .payloadBuilder(builder);

    if (protocol != IpNumber.TCP && protocol != IpNumber.UDP) {
        ipV4Builder.paddingAtBuild(false)
                .padding(pad);
    } else {
        ipV4Builder.paddingAtBuild(true).correctLengthAtBuild(true);
    }

    this.packet1 = ipV4Builder.build();
}
 

@Override
protected IpV4Packet.Builder getIPV4PacketBuilder(int totalLength, int packetLength, Payload payload, PacketData packetData) throws UnknownHostException {
    LOG.info("Create IPV4 Packet");
    TrexIpV4Packet ipV4Packet = prepareIPV4Packet(totalLength, packetLength, payload, packetData);

    int ipv4PacketLength = PacketBuilderHelper.getIPV4PacketLength(packetData.isTaggedVlan(), packetLength, totalLength);
    ipV4Packet.setPacketLength(ipv4PacketLength);
    int udpPacketLength = PacketBuilderHelper.getTcpUdpPacketLength(packetData.isTaggedVlan(), packetLength, totalLength);
    // build  packet
    ipV4Packet.buildPacket(getUdpPacket(payload, udpPacketLength, packetData).getBuilder(), IpNumber.UDP);

    return ipV4Packet.getBuilder();
}
 

@Override
protected IpV4Packet.Builder getIPV4PacketBuilder(int totalLength, int packetLength, Payload payload, PacketData packetData) throws UnknownHostException {
    LOG.info("Create IPV4 Packet");
    TrexIpV4Packet ipV4Packet = prepareIPV4Packet(totalLength, packetLength, payload, packetData);

    int ipv4PacketLength = PacketBuilderHelper.getIPV4PacketLength(packetData.isTaggedVlan(), packetLength, totalLength);
    ipV4Packet.setPacketLength(ipv4PacketLength);
    int tcpPacketLength = PacketBuilderHelper.getTcpUdpPacketLength(packetData.isTaggedVlan(), packetLength, totalLength);
    // build  packet
    ipV4Packet.buildPacket(getTcpPacket(payload, tcpPacketLength, packetData).getBuilder(), IpNumber.TCP);

    return ipV4Packet.getBuilder();
}
 

/**
 * Add VLan to the generated packet
 *
 * @param ethernetPacket
 * @param ipV4Packet
 */
public void addVlanToPacket(TrexEthernetPacket ethernetPacket, IpV4Packet.Builder ipV4Packet) {
    LOG.info("Add VLAN data");
    ethernetPacket.setType(EtherType.DOT1Q_VLAN_TAGGED_FRAMES.value());
    TrexVlanPacket vlanPacket = new TrexVlanPacket();
    if (ipV4Packet == null) {
        ethernetPacket.setAddPad(true);
        vlanPacket.setType((short) 0xFFFF);
    } else {
        vlanPacket.setType(EtherType.IPV4.value());
    }
    vlanPacket.buildPacket(ipV4Packet);
    ethernetPacket.buildPacket(vlanPacket.getBuilder());
}
 

/**
 * Initialize default source/destination address according to first packet
 *
 * @param firstPacket
 */
private void initializeUpdater(Packet firstPacket) {
    defaultSrcAddress = firstPacket.get(IpV4Packet.class).getHeader().getSrcAddr().getHostAddress();
    defaultDstAddress = firstPacket.get(IpV4Packet.class).getHeader().getDstAddr().getHostAddress();
    protocolType = firstPacket.get(IpV4Packet.class).getHeader().getProtocol().name();
    defaultSrcAddressPort = defaultSrcAddress + ":" + getSrcPort(firstPacket);
    defaultDstAddressPort = defaultDstAddress + ":" + getDstPort(firstPacket);
}
 

/**
 * Update packet source/destination address
 *
 * @param packet
 * @return
 */
public Packet updatePacketSrcDst(Packet packet) {
    // initialze default src/dst address and protocol type
    if (packet.get(IpV4Packet.class) != null) {
        if (defaultSrcAddress == null && defaultDstAddress == null) {
            initializeUpdater(packet);
        }
        packet = updateSrcAddress(packet);
        packet = updateDstAddress(packet);
        packet = fixL3L4Checksums(packet);
    }

    return packet;
}
 

/**
 * Extract packet info
 *
 * @param packet
 * @return
 */
private PacketInfo extractPacketInfo(Packet packet) {

    if (packet != null) {
        packetInfo.setPacketHex(formatHex(DatatypeConverter.printHexBinary(packet.getRawData())));
        packetInfo.setPacketRawData(formatPayLoad(new String(packet.getRawData())));
    }

    // defien whether packet has vlan or not
    if(packet.get(Dot1qVlanTagPacket.class) != null){
        packetInfo.setVlanPacket(true);
    }
    // If the packet has Ethernet
    if (packet.get(EthernetPacket.class) != null) {
        packetInfo.setEthernetHex(getHeaderOffset(packet.get(EthernetPacket.class).getHeader().toHexString().toUpperCase()));
        packetInfo.setEthernetRawData(new String());
        packetInfo.setDestMac(packet.get(EthernetPacket.class).getHeader().getDstAddr().toString());
        packetInfo.setSrcMac(packet.get(EthernetPacket.class).getHeader().getSrcAddr().toString());
    }

    // if the packet has IPV4
    if (packet.get(IpV4Packet.class) != null) {
        packetInfo.setIpv4Hex(getHeaderOffset(packet.get(IpV4Packet.class).getHeader().toHexString().toUpperCase()));
        packetInfo.setIpv4RawData(new String());
        packetInfo.setDestIpv4(packet.get(IpV4Packet.class).getHeader().getDstAddr().getHostAddress());
        packetInfo.setSrcIpv4(packet.get(IpV4Packet.class).getHeader().getSrcAddr().getHostAddress());
    }

    // if the packet has TCP
    if (packet.get(TcpPacket.class) != null) {
        packetInfo.setL4Name("TCP");
        packetInfo.setL4Hex(getHeaderOffset(packet.get(TcpPacket.class).getHeader().toHexString().toUpperCase()));
        packetInfo.setL4RawData(new String());
        if (packet.get(TcpPacket.class).getPayload() != null) {
            packetInfo.setPacketPayLoad(getHeaderOffset(spaceHex(Hex.encodeHexString(packet.get(TcpPacket.class).getPayload().getRawData()))));
        } else {
            packetInfo.setPacketPayLoad(null);
        }
    }

    // if the packet has UDP
    if (packet.get(UdpPacket.class) != null) {
        packetInfo.setL4Name("UDP");
        packetInfo.setL4Hex(getHeaderOffset(packet.get(UdpPacket.class).getHeader().toHexString().toUpperCase()));
        packetInfo.setL4RawData(new String());

        if (packet.get(UdpPacket.class).getPayload() != null) {
            packetInfo.setPacketPayLoad(getHeaderOffset(spaceHex(Hex.encodeHexString(packet.get(UdpPacket.class).getPayload().getRawData()))));
        } else {
            packetInfo.setPacketPayLoad(null);
        }
    }
    return packetInfo;
}
 

public static Packet buildIpV4(
		MacAddress srcAddress_mac,
		MacAddress dstAddrress_mac,
		IpV4Packet.Builder builder_ipv4){

	org.pcap4j.packet.Packet.Builder builder=null;
	EtherType etherType=null;
	Packet p=null;
	if(ppp){
		etherType=EtherType.PPPOE_SESSION_STAGE;
		
		UnknownPacket.Builder pppBuilder=new UnknownPacket.Builder();
		byte[] ipData=builder_ipv4.build().getRawData();
		
		byte[] lenb=new byte[2];
		ByteShortConvert.toByteArray((short) (ipData.length+2), lenb, 0);
		
		byte[] pppHead=new byte[8];
		System.arraycopy(pppHead_static, 0, pppHead, 0, pppHead.length);
		System.arraycopy(lenb, 0, pppHead, 4, 2);
		
		byte[] newData=new byte[pppHead.length+ipData.length];
		System.arraycopy(pppHead, 0, newData, 0, pppHead.length);
		System.arraycopy(ipData, 0, newData, 8, ipData.length);
		pppBuilder.rawData(newData);
		
		builder=pppBuilder;
	}else {
		etherType=EtherType.IPV4;
		builder=builder_ipv4;
	}
	
	EthernetPacket.Builder etherBuilder = new EthernetPacket.Builder();
	etherBuilder.dstAddr(dstAddrress_mac)
	.srcAddr(srcAddress_mac)
	.type(etherType)
	.payloadBuilder(builder)
	.paddingAtBuild(true);
	
	p = etherBuilder.build();
	
	return p;
}
 

static Packet createDataPacket(
		MacAddress srcAddress_mac,
		MacAddress dstAddrress_mac,
		Inet4Address srcAddress,short srcPort,
		Inet4Address dstAddress,short dstPort,
		int sequence,int ack, byte[] data,short ident){
	Packet p=null;

	TcpPacket.Builder builder_tcp=new TcpPacket.Builder();
	builder_tcp.payloadBuilder(new UnknownPacket.Builder().rawData(data));
	builder_tcp.correctChecksumAtBuild(true);
	builder_tcp.correctLengthAtBuild(true);
	builder_tcp.paddingAtBuild(true);
	builder_tcp.ack(true);
	builder_tcp.acknowledgmentNumber(ack);
	//builder_tcp.checksum(tcpHeader.getChecksum());
	//builder_tcp.dataOffset((byte)8);
	builder_tcp.dstAddr(dstAddress);
	builder_tcp.dstPort(new TcpPort( dstPort,""));
	builder_tcp.fin(false);
	//builder_tcp.options(tcpHeader.getOptions());
	//builder_tcp.padding(tcpHeader.getPadding());
	builder_tcp.psh(false);
	builder_tcp.reserved((byte) 0);
	builder_tcp.rst(false);
	builder_tcp.sequenceNumber(sequence);
	builder_tcp.srcAddr(srcAddress);
	builder_tcp.srcPort(new TcpPort( srcPort,""));
	builder_tcp.syn(false);
	builder_tcp.urg(false);
	//builder_tcp.urgentPointer(tcpHeader.getUrgentPointer());
	builder_tcp.window( window);

	IpV4Packet.Builder builder_ipv4=new IpV4Packet.Builder();
	builder_ipv4.correctChecksumAtBuild(true);
	builder_ipv4.correctLengthAtBuild(true);
	builder_ipv4.dontFragmentFlag(true);
	builder_ipv4.paddingAtBuild(true);
	builder_ipv4.dstAddr(dstAddress);
	builder_ipv4.fragmentOffset( (short)0);
	//builder_ipv4.headerChecksum(ipV4Header.getHeaderChecksum());
	//short identification= Math.abs(random.nextInt(Short.MAX_VALUE));
	//identification=ident;
	builder_ipv4.identification(ident);
	builder_ipv4.ihl((byte) 5);
	builder_ipv4.moreFragmentFlag(false);
	//builder_ipv4.options(ipV4Header.getOptions());
	//builder_ipv4.padding(ipV4Header.getPadding());

	builder_ipv4.protocol(IpNumber.TCP);
	//builder_ipv4.reservedFlag(ipV4Header.getReservedFlag());
	builder_ipv4.srcAddr(srcAddress);
	builder_ipv4.tos(IpV4Rfc1349Tos.newInstance((byte) 0));
	//builder_ipv4.totalLength( 52);
	builder_ipv4.ttl(ttl);
	builder_ipv4.version(IpVersion.IPV4);
	builder_ipv4.payloadBuilder(builder_tcp);

	p = buildIpV4(srcAddress_mac,dstAddrress_mac,builder_ipv4);

	return p;
}
 

static Packet createAck(
		MacAddress srcAddress_mac,
		MacAddress dstAddrress_mac,
		Inet4Address srcAddress,short srcPort,
		Inet4Address dstAddress,short dstPort,
		int ack_sequence,int sequence,short ident){

	TcpPacket.Builder builder_tcp=new TcpPacket.Builder();
	//builder_tcp.payloadBuilder(new UnknownPacket.Builder().rawData(new byte[0]));
	builder_tcp.correctChecksumAtBuild(true);
	builder_tcp.correctLengthAtBuild(true);
	builder_tcp.paddingAtBuild(true);
	builder_tcp.ack(true);
	builder_tcp.acknowledgmentNumber(ack_sequence);
	//builder_tcp.checksum(tcpHeader.getChecksum());
	//builder_tcp.dataOffset((byte) 8);
	builder_tcp.dstAddr(dstAddress);
	builder_tcp.dstPort(new TcpPort( dstPort,""));
	//builder_tcp.fin(tcpHeader.getFin());

	builder_tcp.psh(false);
	builder_tcp.reserved((byte) 0);
	builder_tcp.rst(false);
	builder_tcp.sequenceNumber(sequence);
	builder_tcp.srcAddr(srcAddress);
	builder_tcp.srcPort(new TcpPort( srcPort,""));
	builder_tcp.syn(false);
	builder_tcp.urg(false);
	//builder_tcp.urgentPointer(tcpHeader.getUrgentPointer());
	builder_tcp.window( window);

	IpV4Packet.Builder builder_ipv4=new IpV4Packet.Builder();
	builder_ipv4.correctChecksumAtBuild(true);
	builder_ipv4.correctLengthAtBuild(true);
	builder_ipv4.paddingAtBuild(true);
	builder_ipv4.dstAddr(dstAddress);
	builder_ipv4.dontFragmentFlag(true);
	builder_ipv4.fragmentOffset( (short) 0);
	//builder_ipv4.headerChecksum(ipV4Header.getHeaderChecksum());
	//short identification= Math.abs(random.nextInt(Short.MAX_VALUE));
	builder_ipv4.identification(ident);
	builder_ipv4.ihl((byte) 5);
	//builder_ipv4.moreFragmentFlag(ipV4Header.getMoreFragmentFlag());
	//builder_ipv4.options(ipV4Header.getOptions());
	//builder_ipv4.padding(ipV4Header.getPadding());

	builder_ipv4.protocol(IpNumber.TCP);
	//		builder_ipv4.reservedFlag(ipV4Header.getReservedFlag());
	builder_ipv4.srcAddr(srcAddress);
	builder_ipv4.tos(IpV4Rfc1349Tos.newInstance((byte) 0));
	//builder_ipv4.totalLength( 52);
	builder_ipv4.ttl(ttl);
	builder_ipv4.version(IpVersion.IPV4);
	builder_ipv4.payloadBuilder(builder_tcp);
	//
	
	Packet p = buildIpV4(srcAddress_mac,dstAddrress_mac,builder_ipv4);
	//System.out.println("自定义确认 "+" identification "+identification+" ack_sequence "+ack_sequence+" # "+tcpPacket.getHeader());
	return p;

}
 

static Packet createSyncAck(
		MacAddress srcAddress_mac,
		MacAddress dstAddrress_mac,
		Inet4Address srcAddress,short srcPort,
		Inet4Address dstAddress,short dstPort,
		int ack_sequence,int sequence,short ident){

	TcpPacket.Builder builder_tcp=new TcpPacket.Builder();
	//builder_tcp.payloadBuilder(new UnknownPacket.Builder().rawData(new byte[0]));
	builder_tcp.correctChecksumAtBuild(true);
	builder_tcp.correctLengthAtBuild(true);
	builder_tcp.paddingAtBuild(true);
	builder_tcp.ack(true);
	builder_tcp.acknowledgmentNumber(ack_sequence);
	//builder_tcp.checksum(tcpHeader.getChecksum());
	//builder_tcp.dataOffset((byte) 8);
	builder_tcp.dstAddr(dstAddress);
	builder_tcp.dstPort(new TcpPort(dstPort,""));
	//builder_tcp.fin(tcpHeader.getFin());


	ArrayList<TcpOption> tcp_options=new ArrayList<TcpOption>();
	
	TcpNoOperationOption nop=TcpNoOperationOption.getInstance();

	TcpMaximumSegmentSizeOption seg_option=new TcpMaximumSegmentSizeOption.Builder().maxSegSize(mtu).correctLengthAtBuild(true).build();
	tcp_options.add(seg_option);
	
	tcp_options.add(nop);
	tcp_options.add(nop);

	TcpSackPermittedOption sack_permit_option=TcpSackPermittedOption.getInstance();
	tcp_options.add(sack_permit_option);
	
	tcp_options.add(nop);

	TcpWindowScaleOption win_option=new TcpWindowScaleOption.Builder().shiftCount(shiftCount).correctLengthAtBuild(true).build();
	tcp_options.add(win_option);

	builder_tcp.options(tcp_options);

	//builder_tcp.padding(tcpHeader.getPadding());
	builder_tcp.psh(false);
	builder_tcp.reserved((byte) 0);
	builder_tcp.rst(false);
	builder_tcp.sequenceNumber(sequence);
	builder_tcp.srcAddr(srcAddress);
	builder_tcp.srcPort(new TcpPort(srcPort,""));
	builder_tcp.syn(true);
	builder_tcp.urg(false);
	//builder_tcp.urgentPointer(tcpHeader.getUrgentPointer());
	builder_tcp.window( window);

	IpV4Packet.Builder builder_ipv4=new IpV4Packet.Builder();
	builder_ipv4.correctChecksumAtBuild(true);
	builder_ipv4.correctLengthAtBuild(true);
	builder_ipv4.paddingAtBuild(true);
	builder_ipv4.dstAddr(dstAddress);
	builder_ipv4.dontFragmentFlag(true);
	builder_ipv4.fragmentOffset((short)0);
	//builder_ipv4.headerChecksum(ipV4Header.getHeaderChecksum());
//	short identification= Math.abs(random.nextInt(Short.MAX_VALUE));
	builder_ipv4.identification(ident);
	builder_ipv4.ihl((byte) 5);
	//builder_ipv4.moreFragmentFlag(ipV4Header.getMoreFragmentFlag());
	//builder_ipv4.options(ipV4Header.getOptions());
	//builder_ipv4.padding(ipV4Header.getPadding());

	builder_ipv4.protocol(IpNumber.TCP);
	//		builder_ipv4.reservedFlag(ipV4Header.getReservedFlag());
	builder_ipv4.srcAddr(srcAddress);
	builder_ipv4.tos(IpV4Rfc1349Tos.newInstance((byte) 0));
	//builder_ipv4.totalLength( 52);
	builder_ipv4.ttl(ttl);
	builder_ipv4.version(IpVersion.IPV4);
	builder_ipv4.payloadBuilder(builder_tcp);
	//
	Packet p = buildIpV4(srcAddress_mac,dstAddrress_mac,builder_ipv4);
	//System.out.println("自定义确认 "+" identification "+identification+" ack_sequence "+ack_sequence+" # "+tcpPacket.getHeader());
	return p;

}
 

static Packet createSync(
			MacAddress srcAddress_mac,
			MacAddress dstAddrress_mac,
			Inet4Address srcAddress,short srcPort,
			Inet4Address dstAddress,short dstPort,
			int sequence,short ident){
		TcpPacket.Builder builder_tcp=new TcpPacket.Builder();
		//builder_tcp.payloadBuilder(new UnknownPacket.Builder().rawData(new byte[0]));
		builder_tcp.correctChecksumAtBuild(true);
		builder_tcp.correctLengthAtBuild(true);
		builder_tcp.paddingAtBuild(true);
		//builder_tcp.ack(true);
		//builder_tcp.acknowledgmentNumber(ack_sequence);
		//builder_tcp.checksum(tcpHeader.getChecksum());
		//builder_tcp.dataOffset((byte) 8);
		builder_tcp.dstAddr(dstAddress);
		builder_tcp.dstPort(new TcpPort( dstPort,""));
		//builder_tcp.fin(tcpHeader.getFin());
		
		TcpNoOperationOption nop=TcpNoOperationOption.getInstance();
		
		ArrayList<TcpOption> tcp_options=new ArrayList<TcpOption>();
		
		TcpMaximumSegmentSizeOption seg_option=new TcpMaximumSegmentSizeOption.Builder().maxSegSize(mtu).correctLengthAtBuild(true).build();
		tcp_options.add(seg_option);

		tcp_options.add(nop);

		TcpWindowScaleOption win_option=new TcpWindowScaleOption.Builder().shiftCount((byte)6).correctLengthAtBuild(true).build();
		tcp_options.add(win_option);

		tcp_options.add(nop);
		tcp_options.add(nop);
		
		TcpSackPermittedOption sack_permit_option=TcpSackPermittedOption.getInstance();
		tcp_options.add(sack_permit_option);
		
		builder_tcp.options(tcp_options);
		
		//builder_tcp.padding(tcpHeader.getPadding());
		builder_tcp.psh(false);
		builder_tcp.reserved((byte) 0);
		builder_tcp.rst(false);
		builder_tcp.sequenceNumber(sequence);
		builder_tcp.srcAddr(srcAddress);
		builder_tcp.srcPort(new TcpPort( srcPort,""));
		builder_tcp.syn(true);
		builder_tcp.urg(false);
		//builder_tcp.urgentPointer(tcpHeader.getUrgentPointer());
		builder_tcp.window( window);

		IpV4Packet.Builder builder_ipv4=new IpV4Packet.Builder();
		builder_ipv4.correctChecksumAtBuild(true);
		builder_ipv4.correctLengthAtBuild(true);
		builder_ipv4.paddingAtBuild(true);
		builder_ipv4.dstAddr(dstAddress);
		builder_ipv4.dontFragmentFlag(true);
		builder_ipv4.fragmentOffset((short)0);
		//builder_ipv4.headerChecksum(ipV4Header.getHeaderChecksum());
		//short identification= Math.abs(random.nextInt(Short.MAX_VALUE));
		builder_ipv4.identification(ident);
		builder_ipv4.ihl((byte) 5);
		//builder_ipv4.moreFragmentFlag(ipV4Header.getMoreFragmentFlag());
		//builder_ipv4.options(ipV4Header.getOptions());
		//builder_ipv4.padding(ipV4Header.getPadding());
		
		builder_ipv4.protocol(IpNumber.TCP);
//		builder_ipv4.reservedFlag(ipV4Header.getReservedFlag());
		builder_ipv4.srcAddr(srcAddress);
		builder_ipv4.tos(IpV4Rfc1349Tos.newInstance((byte) 0));
		//builder_ipv4.totalLength( 52);
		builder_ipv4.ttl(ttl);
		builder_ipv4.version(IpVersion.IPV4);
		builder_ipv4.payloadBuilder(builder_tcp);
//
		Packet p = buildIpV4(srcAddress_mac,dstAddrress_mac,builder_ipv4);
//		IpV4Packet p4=builder_ipv4.build();
//		TcpPacket tcpPacket=builder_tcp.build();
		//selfAckTable.add(identification);
		//System.out.println("自定义确认 "+" identification "+identification+" ack_sequence "+ack_sequence+" # "+tcpPacket.getHeader());
		return p;

	}
 

public static void main(String[] args) throws UnsupportedLookAndFeelException, AWTException, ClassNotFoundException, InterruptedException,
		FontFormatException, InstantiationException, IllegalAccessException, IOException, PcapNativeException, NotOpenException {
	System.setProperty("jna.nosys", "true");
	if (!Sanity.check()) {
		System.exit(1);
	}
	Settings.init();
	Settings.set("autoload", Settings.get("autoload", "0")); //"autoload" is an ini-only toggle for advanced users.
	setupTray();

	getLocalAddr();
	nif = Pcaps.getDevByAddress(addr);
	if (nif == null) {
		JOptionPane.showMessageDialog(null, "The device you selected doesn't seem to exist. Double-check the IP you entered.", "Error", JOptionPane.ERROR_MESSAGE);
		System.exit(1);
	}

	final int addrHash = addr.hashCode();
	final int snapLen = 65536;
	final PromiscuousMode mode = PromiscuousMode.NONPROMISCUOUS;
	final int timeout = 0;
	handle = nif.openLive(snapLen, mode, timeout);
	handle.setFilter("udp && less 150", BpfProgram.BpfCompileMode.OPTIMIZE);

	ui = new Overlay();

	while (running) {
		final Packet packet = handle.getNextPacket();

		if (packet != null) {
			final IpV4Packet ippacket = packet.get(IpV4Packet.class);

			if (ippacket != null) {
				final UdpPacket udppack = ippacket.get(UdpPacket.class);

				if (udppack != null && udppack.getPayload() != null) {
					final int srcAddrHash = ippacket.getHeader().getSrcAddr().hashCode();
					final int dstAddrHash = ippacket.getHeader().getDstAddr().hashCode();
					final int payloadLen = udppack.getPayload().getRawData().length;

					if (active.containsKey(srcAddrHash) && srcAddrHash != addrHash) {
						if (active.get(srcAddrHash) != null && payloadLen == 68  //Packets are STUN related: 56 is request, 68 is response
								&& dstAddrHash == addrHash) {
							ui.setPing(ippacket.getHeader().getSrcAddr(), handle.getTimestamp().getTime() - active.get(srcAddrHash).getTime());
							active.put(srcAddrHash, null); //No longer expect ping
						}
					} else {
						if (payloadLen == 56 && srcAddrHash == addrHash) {
							active.put(ippacket.getHeader().getDstAddr().hashCode(), handle.getTimestamp());
						}
					}
				}
			}
		}
	}
}
 

@Override
public void gotPacket(Packet rawPacket) {
    try {
        LOG.info("Read raw " + rawPacket);
        IpV4Packet ipPacket = rawPacket.get(IpV4Packet.class);
        UdpPacket udpPacket = rawPacket.get(UdpPacket.class);
        byte[] dhcpData = udpPacket.getPayload().getRawData();
        InetSocketAddress remoteAddress = new InetSocketAddress(ipPacket.getHeader().getSrcAddr(), udpPacket.getHeader().getSrcPort().valueAsInt());
        InetSocketAddress localAddress = new InetSocketAddress(ipPacket.getHeader().getDstAddr(), udpPacket.getHeader().getDstPort().valueAsInt());
        DhcpRequestContext context = new DhcpRequestContext(interfaceAddresses, remoteAddress, localAddress);
        DhcpMessage request = decoder.decode(ByteBuffer.wrap(dhcpData));
        LOG.info("Read DHCP " + request);
        DhcpMessage reply = service.getReplyFor(context, request);
        if (reply == null)
            return;
        byte[] replyData = new byte[1536];
        ByteBuffer buffer = ByteBuffer.wrap(replyData);
        encoder.encode(buffer, reply);
        replyData = Arrays.copyOf(replyData, buffer.position());    // Truncate array to writer position.
        UnknownPacket.Builder dhcpBuilder = new UnknownPacket.Builder()
                .rawData(replyData);
        UdpPacket.Builder udpBuilder = new UdpPacket.Builder()
                .payloadBuilder(dhcpBuilder)
                .srcPort(udpPacket.getHeader().getDstPort())
                .dstPort(udpPacket.getHeader().getSrcPort())
                .correctChecksumAtBuild(true)
                .correctLengthAtBuild(true);
        IpV4Packet.Builder ipBuilder = new IpV4Packet.Builder()
                .payloadBuilder(udpBuilder)
                .srcAddr(null) // TODO
                .dstAddr(null) // TODO
                .protocol(IpNumber.UDP)
                .correctChecksumAtBuild(true)
                .correctLengthAtBuild(true)
                .paddingAtBuild(true);
        EthernetPacket.Builder ethernetBuilder = new EthernetPacket.Builder()
                .payloadBuilder(ipBuilder)
                .type(EtherType.IPV4)
                .paddingAtBuild(true);
        Packet replyPacket = ethernetBuilder.build();
        // handle.sendPacket(replyPacket);
    } catch (Exception e) {
        LOG.error("DHCP failed", e);
    }
}
 

@Override
public void gotPacket(Packet rawPacket) {
    try {
        LOG.info("Read raw " + rawPacket);
        IpV4Packet ipPacket = rawPacket.get(IpV4Packet.class);
        UdpPacket udpPacket = rawPacket.get(UdpPacket.class);
        byte[] dhcpData = udpPacket.getPayload().getRawData();
        InetSocketAddress remoteAddress = new InetSocketAddress(ipPacket.getHeader().getSrcAddr(), udpPacket.getHeader().getSrcPort().valueAsInt());
        InetSocketAddress localAddress = new InetSocketAddress(ipPacket.getHeader().getDstAddr(), udpPacket.getHeader().getDstPort().valueAsInt());
        DhcpRequestContext context = new DhcpRequestContext(interfaceAddresses, remoteAddress, localAddress);
        DhcpMessage request = decoder.decode(ByteBuffer.wrap(dhcpData));
        LOG.info("Read DHCP " + request);
        DhcpMessage reply = service.getReplyFor(context, request);
        if (reply == null)
            return;
        byte[] replyData = new byte[1536];
        ByteBuffer buffer = ByteBuffer.wrap(replyData);
        encoder.encode(buffer, reply);
        replyData = Arrays.copyOf(replyData, buffer.position());    // Truncate array to writer position.
        UnknownPacket.Builder dhcpBuilder = new UnknownPacket.Builder()
                .rawData(replyData);
        UdpPacket.Builder udpBuilder = new UdpPacket.Builder()
                .payloadBuilder(dhcpBuilder)
                .srcPort(udpPacket.getHeader().getDstPort())
                .dstPort(udpPacket.getHeader().getSrcPort())
                .correctChecksumAtBuild(true)
                .correctLengthAtBuild(true);
        IpV4Packet.Builder ipBuilder = new IpV4Packet.Builder()
                .payloadBuilder(udpBuilder)
                .srcAddr(null) // TODO
                .dstAddr(null) // TODO
                .protocol(IpNumber.UDP)
                .correctChecksumAtBuild(true)
                .correctLengthAtBuild(true)
                .paddingAtBuild(true);
        EthernetPacket.Builder ethernetBuilder = new EthernetPacket.Builder()
                .payloadBuilder(ipBuilder)
                .type(EtherType.IPV4)
                .paddingAtBuild(true);
        Packet replyPacket = ethernetBuilder.build();
        // handle.sendPacket(replyPacket);
    } catch (Exception e) {
        LOG.error("DHCP failed", e);
    }
}
 

/**
 * Create IPV4 packet
 *
 * @param totalLength
 * @param packetLength
 * @param payload
 * @param packetData
 * @return IPV4 packet
 */
protected abstract IpV4Packet.Builder getIPV4PacketBuilder(int totalLength, int packetLength, Payload payload, PacketData packetData) throws UnknownHostException;
 

/**
 *
 * @return
 */
public IpV4Packet.Builder getBuilder() {
    return ipV4Builder;
}