IPv4PacketImpl (Core Pkts 3.0.5 API)

java.lang.Object
- io.pkts.packet.impl.AbstractPacket
- - io.pkts.packet.impl.IPv4PacketImpl

All Implemented Interfaces:

IPPacket, IPv4Packet, Packet, Cloneable
```
public final class IPv4PacketImpl
extends AbstractPacket
implements IPv4Packet
```
Author:

jonas@jonasborjesson.com

Constructor Summary

Constructors
Constructor and Description

IPv4PacketImpl(Packet parent, Buffer headers, int options, Buffer payload)

Constructors
Constructor and Description
`IPv4PacketImpl(Packet parent, Buffer headers, int options, Buffer payload)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`IPv4Packet`	`clone()`
`long`	`getArrivalTime()` The arrival time of this packet in microseconds relative to epoch (midnight UTC of January 1, 1970).
`String`	`getDestinationIP()` Convenience method for returning the destination IP in a more human readable form.
`short`	`getFragmentOffset()` The fragment offset field, measured in units of eight-byte blocks, is 13 bits long and specifies the offset of a particular fragment relative to the beginning of the original unfragmented IP datagram.
`int`	`getHeaderLength()` The length of the ipv4 headers
`int`	`getIdentification()` Note, this should be treated as a unsigned short.
`int`	`getIpChecksum()` The checksum of the IP-packet.
`Packet`	`getNextPacket()` Get the next frame, or null if there is none.
`byte[]`	`getRawDestinationIP()` Get the raw bytes, either 4 or 16, that represent the destination IP address.
`int`	`getRawDestinationIpInt()` Get the raw destination ip as a 32-bit integer.
`byte[]`	`getRawSourceIP()` Get the raw bytes, either 4 or 16, that represent the source IP.
`int`	`getRawSourceIpInt()` Get the raw source ip as 32-bit integer Note, these are the raw bits and should be treated as such.
`String`	`getSourceIP()` Convenience method for returning the source IP in a more human readable form.
`int`	`getTotalIPLength()` This 16-bit field defines the entire packet (fragment) size, including header and data, in bytes.
`int`	`getVersion()` The version of this ip frame, will always be 4
`boolean`	`isDontFragmentSet()` The DF flag is part of the three-bit flag field and those flags are: (in order, from high order to low order):
`boolean`	`isFragmented()`
`boolean`	`isMoreFragmentsSet()` The MF flag is part of the three-bit flag field and those flags are: (in order, from high order to low order):
`boolean`	`isReservedFlagSet()` The Reserved flag is part of the three-bit flag field and those flags are: (in order, from high order to low order):
`void`	`reCalculateChecksum()` Whenever we change a value in the IP packet we need to update the checksum as well.
`void`	`setDestinationIP(byte a, byte b, byte c, byte d)`
`void`	`setDestinationIP(int a, int b, int c, int d)` Setting an IPv4 address the fast way! Specify each part separately.
`void`	`setDestinationIP(String destinationIP)` Set the destination IP of this `IPv4Packet`.
`void`	`setSourceIP(byte a, byte b, byte c, byte d)` Setting an IPv4 address the fast(est?) way! Specify each part separately.
`void`	`setSourceIP(int a, int b, int c, int d)` Setting an IPv4 address the fast way! Specify each part separately.
`void`	`setSourceIP(String sourceIp)` Set the source IP of this `IPv4Packet`.
`void`	`setTotalLength(int length)`
`String`	`toString()`
`void`	`verify()` Calling this method will force the packet to completely parse its data and check so that all the information conforms to whatever rules this packet needs to follow.
`boolean`	`verifyIpChecksum()`
`void`	`write(OutputStream out, Buffer payload)` Writes this packet to the `OutputStream` with the supplied payload.

Methods inherited from class io.pkts.packet.impl.AbstractPacket
checkParent, getName, getPacket, getParentPacket, getPayload, getProtocol, hasProtocol, write

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.pkts.packet.Packet
getName, getPacket, getParentPacket, getPayload, getProtocol, hasProtocol, write

- Constructor Detail
  - IPv4PacketImpl
```
public IPv4PacketImpl(Packet parent,
                      Buffer headers,
                      int options,
                      Buffer payload)
```
- Method Detail
  - getIpChecksum
```
public int getIpChecksum()
```
    Description copied from interface: IPv4Packet
    
    The checksum of the IP-packet. The checksum in an IP-packet is a 16 bit checksum of the header bytes (which the checksum set to zero) and is returned as a unsigned short (hence an int) Checkout
    
    Specified by:
    
    getIpChecksum in interface IPv4Packet
    
    Returns:
  - getRawSourceIP
```
public byte[] getRawSourceIP()
```
    Description copied from interface: IPPacket
    
    Get the raw bytes, either 4 or 16, that represent the source IP.
    
    Specified by:
    
    getRawSourceIP in interface IPPacket
    
    Returns:
  - getRawSourceIpInt
```
public int getRawSourceIpInt()
```
    Get the raw source ip as 32-bit integer Note, these are the raw bits and should be treated as such. If you really want to print it, then you should treat it as unsigned
    
    Returns:
  - getSourceIP
```
public String getSourceIP()
```
    Convenience method for returning the source IP in a more human readable form.
    
    Specified by:
    
    getSourceIP in interface IPPacket
    
    Returns:
  - getRawDestinationIP
```
public byte[] getRawDestinationIP()
```
    Description copied from interface: IPPacket
    
    Get the raw bytes, either 4 or 16, that represent the destination IP address.
    
    Specified by:
    
    getRawDestinationIP in interface IPPacket
    
    Returns:
  - getRawDestinationIpInt
```
public int getRawDestinationIpInt()
```
    Get the raw destination ip as a 32-bit integer. Note, these are the raw bits and should be treated as such. If you really want to print it, then you should treat it as unsigned
    
    Returns:
  - getDestinationIP
```
public String getDestinationIP()
```
    Convenience method for returning the destination IP in a more human readable form.
    
    Specified by:
    
    getDestinationIP in interface IPPacket
    
    Returns:
  - verify
```
public void verify()
```
    Calling this method will force the packet to completely parse its data and check so that all the information conforms to whatever rules this packet needs to follow. E.g., if this happens to be a SIP packet, then it will check if it has the mandatory headers etc. Some simpler packets, such as the IPPacket, hardly does anything in this method but more complex protocols such as SIP (once again), HTTP etc can spend quite some time verifying everything, which is why you don't want to do it unless you really have to. In general, yajpcap has the philosophy of "assume that everything is ok until things blow up and then deal with it"
    
    Specified by:
    
    verify in interface Packet
    
    Overrides:
    
    verify in class AbstractPacket
  - getArrivalTime
```
public long getArrivalTime()
```
    Description copied from interface: Packet
    The arrival time of this packet in microseconds relative to epoch (midnight UTC of January 1, 1970). Note, since this returns with microseconds precision (which may or may not be relevant depending on the hardware on which the packet was captured on) and you wish to format this arrival time into a more human readable format you could use the SimpleDateFormat but it can only handle milliseconds precision (you will have to write your own date formatter if you want microseconds). Here is a snippet illustrating how to turn the arrival time of the packet into a human readable date
```
 Packet p = ...;
 SimpleDateFormat formatter = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss.SSS");
 Date date = new Date(p.getArrivalTime() / 1000);
 System.out.println("Arrival time: " + formatter.format(date));
 
```
    Note how an integer devision is performed on the arrival time to "cut off" the microseconds from the time stamp
    Specified by:
    
    getArrivalTime in interface Packet
    
    Returns:
    
    the arrival time of the packet in microseconds since the start of the epoch
  - write
```
public void write(OutputStream out,
                  Buffer payload)
           throws IOException
```
    Description copied from interface: Packet
    
    Writes this packet to the OutputStream with the supplied payload. You can use this method to e.g. write a raw UDPPacket to the stream with this payload. Note, if the UDPPacket already had a payload it will be ignored so use this method with care.
    
    Specified by:
    
    write in interface Packet
    
    Throws:
    
    IOException
  - getTotalIPLength
```
public int getTotalIPLength()
```
    Description copied from interface: IPPacket
    
    This 16-bit field defines the entire packet (fragment) size, including header and data, in bytes. The minimum-length packet is 20 bytes (20-byte header + 0 bytes data) and the maximum is 65,535 bytes — the maximum value of a 16-bit word. The largest datagram that any host is required to be able to reassemble is 576 bytes, but most modern hosts handle much larger packets. Sometimes subnetworks impose further restrictions on the packet size, in which case datagrams must be fragmented. Fragmentation is handled in either the host or router in IPv4. (source: http://en.wikipedia.org/wiki/IPv4)
    
    Specified by:
    
    getTotalIPLength in interface IPPacket
    
    Returns:
  - setTotalLength
```
public void setTotalLength(int length)
```
  - setSourceIP
```
public void setSourceIP(int a,
                        int b,
                        int c,
                        int d)
```
    Description copied from interface: IPv4Packet
    
    Setting an IPv4 address the fast way! Specify each part separately. E.g., setting 192.168.0.100 would be accomplished like so: #setSourceIP(192, 168, 0, 100)
    
    Specified by:
    
    setSourceIP in interface IPv4Packet
    
    Parameters:
    
    a - the first part of the IPv4 address, e.g. 192
    
    b - the second part of the IPv4 address, e.g. 168
    
    c - the third part of the IPv4 address, e.g. 0
    
    d - the fourth part of the IPv4 address, e.g. 100
  - setSourceIP
```
public void setSourceIP(byte a,
                        byte b,
                        byte c,
                        byte d)
```
    Description copied from interface: IPv4Packet
    
    Setting an IPv4 address the fast(est?) way! Specify each part separately. E.g., setting 192.168.0.100 would be accomplished like so:
    
    Specified by:
    
    setSourceIP in interface IPv4Packet
  - setDestinationIP
```
public void setDestinationIP(int a,
                             int b,
                             int c,
                             int d)
```
    Description copied from interface: IPv4Packet
    
    Setting an IPv4 address the fast way! Specify each part separately. E.g., setting 192.168.0.100 would be accomplished like so: #setSourceIP(192, 168, 0, 100)
    
    Specified by:
    
    setDestinationIP in interface IPv4Packet
    
    Parameters:
    
    a - the first part of the IPv4 address, e.g. 192
    
    b - the second part of the IPv4 address, e.g. 168
    
    c - the third part of the IPv4 address, e.g. 0
    
    d - the fourth part of the IPv4 address, e.g. 100
  - setDestinationIP
```
public void setDestinationIP(byte a,
                             byte b,
                             byte c,
                             byte d)
```
    Specified by:
    
    setDestinationIP in interface IPv4Packet
  - setSourceIP
```
public void setSourceIP(String sourceIp)
```
    Description copied from interface: IPv4Packet
    
    Set the source IP of this IPv4Packet. Note, using IPv4Packet.setSourceIP(int, int, int, int) will be must faster so try and use it instead.
    
    Specified by:
    
    setSourceIP in interface IPPacket
    
    Specified by:
    
    setSourceIP in interface IPv4Packet
  - setDestinationIP
```
public void setDestinationIP(String destinationIP)
```
    Description copied from interface: IPv4Packet
    
    Set the destination IP of this IPv4Packet. Note, using IPv4Packet.setDestinationIP(int, int, int, int) will be must faster so try and use it instead.
    
    Specified by:
    
    setDestinationIP in interface IPPacket
    
    Specified by:
    
    setDestinationIP in interface IPv4Packet
  - reCalculateChecksum
```
public void reCalculateChecksum()
```
    Whenever we change a value in the IP packet we need to update the checksum as well.
    
    Specified by:
    
    reCalculateChecksum in interface IPv4Packet
  - verifyIpChecksum
```
public boolean verifyIpChecksum()
```
    Specified by:
    
    verifyIpChecksum in interface IPv4Packet
  - clone
```
public IPv4Packet clone()
```
    Specified by:
    
    clone in interface IPPacket
    
    Specified by:
    
    clone in interface IPv4Packet
    
    Specified by:
    
    clone in interface Packet
    
    Specified by:
    
    clone in class AbstractPacket
  - getNextPacket
```
public Packet getNextPacket()
                     throws IOException
```
    Description copied from interface: Packet
    
    Get the next frame, or null if there is none. Note, if there isn't another frame but there is still raw data within this frame, it only means that we didn't recognize the payload.
    
    Specified by:
    
    getNextPacket in interface Packet
    
    Returns:
    
    Throws:
    
    IOException
  - getVersion
```
public int getVersion()
```
    The version of this ip frame, will always be 4
    
    Specified by:
    
    getVersion in interface IPPacket
    
    Returns:
  - getHeaderLength
```
public int getHeaderLength()
```
    The length of the ipv4 headers
    
    Specified by:
    
    getHeaderLength in interface IPPacket
    
    Returns:
  - isFragmented
```
public boolean isFragmented()
```
    Specified by:
    
    isFragmented in interface IPPacket
    
    Specified by:
    
    isFragmented in interface IPv4Packet
    
    Returns:
  - isReservedFlagSet
```
public boolean isReservedFlagSet()
```
    The Reserved flag is part of the three-bit flag field and those flags are: (in order, from high order to low order):
```
 bit 0: Reserved; must be zero.
 bit 1: Don't Fragment (DF)
 bit 2: More Fragments (MF)
 
```
    (source http://en.wikipedia.org/wiki/IPv4)
    Specified by:
    
    isReservedFlagSet in interface IPv4Packet
    
    Returns:
    
    should always return false
  - isDontFragmentSet
```
public boolean isDontFragmentSet()
```
    The DF flag is part of the three-bit flag field and those flags are: (in order, from high order to low order):
```
 bit 0: Reserved; must be zero.
 bit 1: Don't Fragment (DF)
 bit 2: More Fragments (MF)
 
```
    If the DF flag is set, and fragmentation is required to route the packet, then the packet is dropped. This can be used when sending packets to a host that does not have sufficient resources to handle fragmentation. It can also be used for Path MTU Discovery, either automatically by the host IP software, or manually using diagnostic tools such as ping or traceroute. For unfragmented packets, the MF flag is cleared. For fragmented packets, all fragments except the last have the MF flag set. The last fragment has a non-zero Fragment Offset field, differentiating it from an unfragmented packet. (source http://en.wikipedia.org/wiki/IPv4)
    Specified by:
    
    isDontFragmentSet in interface IPv4Packet
    
    Returns:
  - isMoreFragmentsSet
```
public boolean isMoreFragmentsSet()
```
    The MF flag is part of the three-bit flag field and those flags are: (in order, from high order to low order):
```
 bit 0: Reserved; must be zero.
 bit 1: Don't Fragment (DF)
 bit 2: More Fragments (MF)
 
```
    If the DF flag is set, and fragmentation is required to route the packet, then the packet is dropped. This can be used when sending packets to a host that does not have sufficient resources to handle fragmentation. It can also be used for Path MTU Discovery, either automatically by the host IP software, or manually using diagnostic tools such as ping or traceroute. For unfragmented packets, the MF flag is cleared. For fragmented packets, all fragments except the last have the MF flag set. The last fragment has a non-zero Fragment Offset field, differentiating it from an unfragmented packet. (source http://en.wikipedia.org/wiki/IPv4)
    Specified by:
    
    isMoreFragmentsSet in interface IPv4Packet
    
    Returns:
  - getFragmentOffset
```
public short getFragmentOffset()
```
    Description copied from interface: IPv4Packet
    
    The fragment offset field, measured in units of eight-byte blocks, is 13 bits long and specifies the offset of a particular fragment relative to the beginning of the original unfragmented IP datagram. The first fragment has an offset of zero. This allows a maximum offset of (213 – 1) × 8 = 65,528 bytes, which would exceed the maximum IP packet length of 65,535 bytes with the header length included (65,528 + 20 = 65,548 bytes). (source http://en.wikipedia.org/wiki/IPv4)
    
    Specified by:
    
    getFragmentOffset in interface IPPacket
    
    Specified by:
    
    getFragmentOffset in interface IPv4Packet
    
    Returns:
  - getIdentification
```
public int getIdentification()
```
    Description copied from interface: IPPacket
    
    Note, this should be treated as a unsigned short. This field is an identification field and is primarily used for uniquely identifying fragments of an original IP datagram. Some experimental work has suggested using the ID field for other purposes, such as for adding packet-tracing information to help trace datagrams with spoofed source addresses (source http://en.wikipedia.org/wiki/IPv4)
    
    Specified by:
    
    getIdentification in interface IPPacket
    
    Returns:
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class IPv4PacketImpl

Constructor Summary

Method Summary

Methods inherited from class io.pkts.packet.impl.AbstractPacket

Methods inherited from class java.lang.Object

Methods inherited from interface io.pkts.packet.Packet

Constructor Detail

IPv4PacketImpl

Method Detail

getIpChecksum

getRawSourceIP

getRawSourceIpInt

getSourceIP

getRawDestinationIP

getRawDestinationIpInt

getDestinationIP

verify

getArrivalTime

write

getTotalIPLength

setTotalLength

setSourceIP

setSourceIP

setDestinationIP

setDestinationIP

setSourceIP

setDestinationIP

reCalculateChecksum

verifyIpChecksum

clone

getNextPacket

getVersion

getHeaderLength

isFragmented

isReservedFlagSet

isDontFragmentSet

isMoreFragmentsSet

getFragmentOffset

getIdentification

toString