Java JPacket.getHeader方法代码示例

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
/**
 * In this function the packet is pseudonymization and checksums are recalculated as configured.
 *
 * @param packet the captured packet
 */
public void modifyPacket(JPacket packet) {
    if ((!DNS_ONLY) || isDns(packet)) {
        // If the original ip4 checksum is not valid, the checksum should not be modified.
        boolean originalChecksumValid = true;

        if (_pseudonymizerMap.containsKey(JProtocol.IP4) && packet.hasHeader(Ip4.ID)) {
            Ip4 ip4 = packet.getHeader(new Ip4());
            originalChecksumValid = ip4.isChecksumValid();
            pseudonymizeIP4(_pseudonymizerMap.get(JProtocol.IP4), ip4);
        } else if (_pseudonymizerMap.containsKey(JProtocol.IP6) && packet.hasHeader(Ip6.ID)) {
            Ip6 ip6 = packet.getHeader(new Ip6());
            pseudonymizeIP6(_pseudonymizerMap.get(JProtocol.IP6), ip6);
        }
        // Checksum updates.
        recalculateChecksums(packet, originalChecksumValid);
    }
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
/**
 * Recalculates the checksums as configured.
 *
 * @param packet the captured packet
 * @param originalChecksumValid boolean that holds whether the checksum was valid before modification.
 */
private void recalculateChecksums(final JPacket packet, final boolean originalChecksumValid) {
    for (int checksumType : _checksumList) {
        // The ip4 or ip6 checksum should be updated first.
        if (checksumType == Ip4.ID && originalChecksumValid) {
            if (packet.hasHeader(Ip4.ID)) {
                Ip4 ip4 = packet.getHeader(new Ip4());
                ip4.recalculateChecksum();
            }
        }
        if (checksumType == Udp.ID && packet.hasHeader(Udp.ID)) {
            recalulateUdpChecksum(packet);
        }
        if (checksumType == Tcp.ID && packet.hasHeader(Tcp.ID)) {
            Tcp tcp = packet.getHeader(new Tcp());
            tcp.recalculateChecksum();
        }
        if (checksumType == Icmp.ID && packet.hasHeader(Icmp.ID)) {
            Icmp icmp = packet.getHeader(new Icmp());
            icmp.recalculateChecksum();
        }
    }
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
public void updateFrame_From_Packet(JPacket local_jPacket){
	
	IEC61850_GOOSE_Header goose_header = local_jPacket.getHeader( new IEC61850_GOOSE_Header());
	
	this.test = goose_header.test();
	this.ndsCom = goose_header.ndsCom();
	this.stNum = goose_header.stNum();
	this.sqNum = goose_header.sqNum();
	this.timeAllowedToLive = goose_header.timeAllowedToLive();
	
	// Reading the time in the header updates the time quality information
	this.utc_time = goose_header.utc();
	
	this.leapSecondsKnown = goose_header.leapSecondsKnown;
	this.clockFailure = goose_header.clockFailure;
	this.clockNotSynchronized = goose_header.clockNotSynchronized;
	this.timeAccuracy = goose_header.timeAccuracy;
	
	// We decode the data
	gooseData.decodeData(goose_header.gooseData());
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
/**
 * Within JNetPcap the UDP checksum recalculation does not work.
 * It is reimplemented here.
 *
 * @param packet packet to recalculate the udp checksum over.
 */
private void recalulateUdpChecksum(final JPacket packet) {
    final Udp udp = packet.getHeader(new Udp());
    udp.checksum(0); // The checksum is left out of the calculation but reset for correctness.
    final byte[] mergedBytes;
    if (packet.hasHeader(Ip4.ID)) {
        Ip4 ip4 = packet.getHeader(new Ip4());
        mergedBytes = constructIp4UdpChecksumByteArray(ip4, udp);
    } else {
        Ip6 ip6 = packet.getHeader(new Ip6());
        mergedBytes = constructIp6UdpChecksumByteArray(ip6, udp);
    }
    udp.checksum(ByteBuffer.wrap(calculateInternetChecksum(mergedBytes)).order(ByteOrder.BIG_ENDIAN).getShort());
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
/**
 * Check for DNS packets if required that only DNS packets should be handled.
 *
 * @param packet the captured packet.
 * @return true if the packet is a dns packet.
 */
private boolean isDns(final JPacket packet) {
    if (packet.hasHeader(Udp.ID)) {
        final Udp udp = packet.getHeader(new Udp());
        return (udp.source() == 53 || udp.destination() == 53);
    }
    else if (packet.hasHeader(Tcp.ID)) {
        final Tcp tcp = packet.getHeader(new Tcp());
        return (tcp.source() == 53 || tcp.destination() == 53);
    }
    return false;
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
/**
 * Test ip4 cr c16 pkt1.
 */
public void testIp4CRC16Pkt1() {

	JPacket packet = super.getPcapPacket(TestUtils.L2TP, 0);
	Ip4 ip = packet.getHeader(new Ip4());

	int computed = Checksum.inChecksum(ip, 0, ip.size());

	System.out.printf("1chunk=%x\n", computed);
	System.out.printf("shoudbe=%x checksum=%x\n",
			Checksum.inChecksumShouldBe(ip.checksum(), computed),
			ip.checksum());

	assertTrue(ip.isChecksumValid());
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
/**
 * Test ip4 cr c16 pkt2.
 */
public void testIp4CRC16Pkt2() {

	JPacket packet = super.getPcapPacket(TestUtils.L2TP, 1);
	Ip4 ip = packet.getHeader(new Ip4());

	assertEquals(ip.calculateChecksum(), ip.checksum());
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
/**
 * Test ip4 cr c16 pkt50.
 */
public void testIp4CRC16Pkt50() {

	JPacket packet = super.getPcapPacket(TestUtils.L2TP, 46 - 1);
	Ip4 ip = packet.getHeader(new Ip4());

	int crc;
	assertEquals(ip.checksum(), ip.calculateChecksum());

	// System.out.printf("ip.crc=%x computed=%x\n", ip.checksum(), crc);
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
/**
 * Test tcp options.
 * 
 * <pre>
 * 
 * </pre>
 */
public void testTcpOptions() {
	JPacket packet = TestUtils.getPcapPacket(SMALL_IMAP, 1 - 1);
	System.out.println(packet.getState().toDebugString());
	System.out.println(packet.toString());

	Tcp tcp = packet.getHeader(new Tcp());
	Tcp.Timestamp ts = new Tcp.Timestamp();

	if (tcp.hasSubHeader(ts)) {
		System.out.printf("tsval=%d tsecr=%d%n", ts.tsval(), ts.tsecr());
	}
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
/**
 * Test send packet using j buffer.
 * 
 * @throws UnknownHostException
 *           the unknown host exception
 */
public void testSendPacketUsingJBuffer() throws UnknownHostException {
	JPacket packet =
	    new JMemoryPacket(JProtocol.ETHERNET_ID,
	        "0016b6c13cb10021 5db0456c08004500 "
	            + "00340e8e40008006 9c54c0a80165d822 "
	            + "b5b1c1cf005020ce 4303000000008002 "
	            + "2000d94300000204 05b4010303020101 " + "0402");

	InetAddress dst = InetAddress.getByName("201.1.1.1");
	InetAddress src = InetAddress.getByName("192.168.1.1");

	Ip4 ip = packet.getHeader(new Ip4());
	Tcp tcp = packet.getHeader(new Tcp());

	ip.destination(dst.getAddress());
	ip.source(src.getAddress());

	ip.checksum(ip.calculateChecksum());
	tcp.checksum(tcp.calculateChecksum());
	packet.scan(Ethernet.ID);

	System.out.println(packet);
	List<PcapIf> alldevs = new ArrayList<PcapIf>(); // Will be filled with NICs
	StringBuilder errbuf = new StringBuilder(); // For any error msgs
	/***************************************************************************
	 * First get a list of devices on this system
	 **************************************************************************/
	int r = Pcap.findAllDevs(alldevs, errbuf);
	if (r == Pcap.NOT_OK || alldevs.isEmpty()) {
		System.err.printf("Can't read list of devices, error is %s", errbuf
		    .toString());
		return;
	}
	PcapIf device = alldevs.get(0); // We know we have atleast 1 device
	/***************************************************************************
	 * Second we open a network interface
	 **************************************************************************/
	int snaplen = 64 * 1024; // Capture all packets, no trucation
	int flags = Pcap.MODE_NON_PROMISCUOUS; // capture all packets
	int timeout = 10 * 1000; // 10 seconds in millis
	Pcap pcap =
	    Pcap.openLive(device.getName(), snaplen, flags, timeout, errbuf);
	System.out.println("Device ->" + device.getName());

	try {
		if (pcap.sendPacket(packet) != Pcap.OK) {
			System.err.println(pcap.getErr());
		}
	} finally {
		/*************************************************************************
		 * Lastly we close
		 ************************************************************************/
		pcap.close();
		
		
	}
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
/**
 * Checks if is bound.
 * 
 * @param packet
 *          the packet
 * @param offset
 *          the offset
 * @return true, if is bound
 * @see org.jnetpcap.packet.JBinding#isBound(org.jnetpcap.packet.JPacket, int)
 */
public boolean isBound(JPacket packet, int offset) {

	packet.getHeader(header);

	return header.isHeaderTruncated() == false && annotatedBound.isBound(packet, offset, header);
}