Java JPacket.hasHeader方法代码示例

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包/类
/**
 * Test j header is fragmented.
 */
public void testJHeaderIsFragmented() {
	JPacket packet = TestUtils.getPcapPacket(TestUtils.REASEMBLY, 1 - 1);
	Ethernet eth = new Ethernet();

	if (packet.hasHeader(eth)) {
		assertFalse(eth.isFragmented());
	}

	Ip4 ip = new Ip4();
	if (packet.hasHeader(ip)) {
		assertTrue(ip.isFragmented());
	}

	Icmp icmp = new Icmp();
	if (packet.hasHeader(icmp)) {
		assertTrue(ip.isFragmented());
	}

}
 

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 fragment flag directly.
 */
public void testIp4FragmentFlagDirectly() {
	JPacket packet = TestUtils.getPcapPacket(TestUtils.REASEMBLY, 1 - 1);
	Ethernet eth = new Ethernet();

	if (packet.hasHeader(eth)) {
		// System.out.println(eth);
		// System.out.printf("flags=%x\n", eth.getState().getFlags());
		assertNotSame(JHeader.State.FLAG_HEADER_FRAGMENTED, (eth.getState()
				.getFlags() & JHeader.State.FLAG_HEADER_FRAGMENTED));
	}

	Ip4 ip = new Ip4();
	if (packet.hasHeader(ip)) {
		// System.out.println(ip);
		// System.out.printf("flags=%x\n", ip.getState().getFlags());
		assertEquals(JHeader.State.FLAG_HEADER_FRAGMENTED, (ip.getState()
				.getFlags() & JHeader.State.FLAG_HEADER_FRAGMENTED));
	}

	Icmp icmp = new Icmp();
	if (packet.hasHeader(icmp)) {
		// System.out.println(icmp);
		// System.out.printf("flags=%x\n", icmp.getState().getFlags());
		assertEquals(JHeader.State.FLAG_HEADER_FRAGMENTED, (icmp.getState()
				.getFlags() & JHeader.State.FLAG_HEADER_FRAGMENTED));
	}

}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
@Test
public void testRTP() {

	boolean foundRtp = false;
	for (JPacket packet : TestUtils.getIterable(FILE)) {
		if (packet.hasHeader(Rtp.ID)) {
			foundRtp = true;
			out.println(packet.getState().toDebugString());
			out.printf("#%d - RTP%n", packet.getFrameNumber());
		}
	}

	TestCase.assertTrue("RTP not found", foundRtp);
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
@Test
public void testRTCP() {

	long mask = JProtocol.createMaskFromIds(RtcpSenderReport.ID,
			RtcpReceiverReport.ID, RtcpSDES.ID, RtcpApp.ID, RtcpBye.ID);

	boolean foundRtcp = false;
	JPacket.getDefaultScanner().setFrameNumber(1);
	for (JPacket packet : TestUtils.getIterable(FILE)) {
		int group = JProtocol.maskToGroup(mask);
		out.printf("group=%d mask=0x%016X map=%016X%n", group, mask, packet
				.getState().get64BitHeaderMap(group));

		if (packet.hasHeader(Udp.ID)) {
			out.println(packet.getHeader(new Udp()));
		}
		out.println(packet.getState().toDebugString());
		if (packet.hasAnyHeader(mask)) {
			foundRtcp = true;
			out.println(packet);
			out.printf("#%d - RTCP%n", packet.getFrameNumber());

			break;
		}
		
		if (packet.getFrameNumber() == 634) {
			break;
		}
	}

	TestCase.assertTrue("RTCP not found", foundRtcp);
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
/**
 * _test1.
 */
public void _test1() {

	JPacket packet = TestUtils.getPcapPacket("tests/test-afs.pcap", 0);

	MyHeader my = new MyHeader();

	if (packet.hasHeader(my) && my.version() == 4) {
		System.out.printf("found it id=%d\n", my.getId());

		System.out.println(packet.toString());
	} else {
		System.out.printf("not found id=%d\n", my.getId());
	}
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
/**
 * Test syntax text.
 */
public void testSyntaxText() {
	Ip4 ip = new Ip4();
	Ip4.Timestamp ts = new Ip4.Timestamp();
	Ip4.LooseSourceRoute lsroute = new Ip4.LooseSourceRoute();
	Ip4.StrictSourceRoute ssroute = new Ip4.StrictSourceRoute();
	Ip4.RecordRoute record = new Ip4.RecordRoute();

	JPacket packet =
	    TestUtils.getPcapPacket("tests/test-icmp-recordroute-opt.pcap", 0);

	if (packet.hasHeader(ip) && ip.hasSubHeaders()) {

		if (ip.hasSubHeader(lsroute)) {
			System.out.println("LooseSource");
		}

		if (ip.hasSubHeader(ssroute)) {
			System.out.println("StrictSource");
		}

		if (ip.hasSubHeader(ts)) {
			System.out.println("Timestamp");
		}
		
		if (ip.hasSubHeader(record)) {
			System.out.println("RecordRoute");
		}

	}
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
@Bind(to = SctpData.class)
public static boolean bindToTcp(JPacket packet, SctpData data) {
	final Sctp sctp = local.get();
	return packet.hasHeader(sctp)
			&& (sctp.destination() == 3868 || sctp.source() == 3868);
}
 

import org.jnetpcap.packet.JPacket; //导入方法依赖的package包/类
public void updateFrame_From_UnknownPacket(JPacket local_jPacket) throws IEC61850_GOOSE_Exception
{
	// We initialise empty headers. Required to decode the packet.
	Ethernet eth_header = new Ethernet();
       IEEE802dot1q dot1q_header = new IEEE802dot1q();
       IEC61850_GOOSE_Header goose_header = new IEC61850_GOOSE_Header();
       
       if (local_jPacket.hasHeader(eth_header)) 
       {  
       	this.destinationMacAddress = FormatUtils.mac(eth_header.destination());
   		this.sourceMacAddress = FormatUtils.mac(eth_header.source());
       }
       else
       {
       	throw new IEC61850_GOOSE_Exception("Typing to decode an unknown packet of a type that is not of type Ethernet: " 
       			+ "Frame number: " + local_jPacket.getFrameNumber() 
       			+ "Ethernet source: " +  FormatUtils.mac(eth_header.source())
       			+ "Ethernet destination: " +  FormatUtils.mac(eth_header.destination())
       			+ "Packet type: " + eth_header.type());
       }
       // We have to check for IEEE 802.1Q NOTE: Q in Q not supported
       if (local_jPacket.hasHeader(dot1q_header))
       {
       	/* May be usefull in the future
       	int dot1q_priority = dot1q_header.priority();
       	int dot1q_cfi = dot1q_header.cfi();
       	int dot1q_id = dot1q_header.id();
       	*/
       }
   	
       if (local_jPacket.hasHeader(goose_header))
       {
       	if (goose_header.isValidHeader() == false)
        	throw new IEC61850_GOOSE_Exception("Typing to decode an unknown packet that does not have a GOOSE header: " 
        			+ "Frame number: " + local_jPacket.getFrameNumber() 
        			+ "GOOSE header error: " +  goose_header.headerError);
       	
       	else
       	{
       		// We decode the content of the header
       		this.appID = goose_header.appID();
       		
       		this.goCBref = goose_header.goCBref();
       		this.datSet = goose_header.datSet();
       		this.goID = goose_header.goID();

       		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();
       		this.confRevGoose = goose_header.confRev();
       		this.numDatSetEntries = goose_header.numDatSetEntries();
       		
       		// 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 set the data length
       		stNum_length = sizeOf(stNum);
       		sqNum_length = sizeOf(sqNum);
   
       		// Verify frame validity
       		if ((new Date()).getTime() - this.utc_time > this.timeAllowedToLive)
       			frameValidity = IEC61850_GOOSE_FrameValidityType.questionable;
       		else
       			frameValidity = IEC61850_GOOSE_FrameValidityType.good;
       		
       		// We read the payload
       		gooseData = new IEC61850_GOOSE_Data(goose_header.numDatSetEntries());
       		
       		// We decode the data
       		gooseData.decodeData(goose_header.gooseData());
       	}
       }
}