com.ibm.as400.util.commtrace.IP4Header Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
The newest version!
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: IP4Header.java
//
// The source code contained herein is licensed under the IBM Public License
// Version 1.0, which has been approved by the Open Source Initiative.
// Copyright (C) 2002 International Business Machines Corporation and
// others. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.util.commtrace;
import com.ibm.as400.access.Trace;
import com.ibm.as400.access.AS400SecurityException;
import java.util.Properties;
/**
* A Internet Protocol v4 Header.
* Extends Header's methods to parse, print, and allow easy access to the ICMPv4 Header.
*/
public class IP4Header extends Header {
private static final String CLASS="IP4Header";
// Fields defined in RFC 760
Field version= new Dec(rawheader.slice(0, 4));
Field internetheaderl= new Dec(rawheader.slice(4, 4));
Field typeofservice= new Hex(rawheader.slice(8, 8));
Field dscp= new Dec(rawheader.slice(8, 6));
Field ecn= new Dec(rawheader.slice(14, 2)); // RFC 3168
Field totallength= new Dec(rawheader.slice(16, 16));
Field identification= new Hex(rawheader.slice(32, 16));
Field flag= new FragmentFlag(rawheader.slice(48, 2));
Field flag2= new FragmentFlag(rawheader.slice(50, 4));
Field fragmentoffset= new Dec(rawheader.slice(52, 12));
Field timetolive= new Dec(rawheader.slice(64, 8));
Field protocol= new Dec(rawheader.slice(72, 8));
Field headerchecksum= new Dec(rawheader.slice(80, 16));
Field src= new IP4Address(rawheader.slice(96, 32));
Field dst= new IP4Address(rawheader.slice(128, 32));
Field options=
new Hex(
rawheader.slice(
160,
((Integer.parseInt(internetheaderl.toString()) * 8) - 40)));
// Fields from the RFC
private final static String RES= "RESERVED";
private final static String ICMP= "ICMP";
private final static String IGMP= "IGMP";
private final static String TCP= "TCP";
private final static String UDP= "UDP";
private final static String IPV6= "IPv6";
private final static String UNK= "Unknown";
private final static String MAY= "MAY";
private final static String DONT= "DON'T";
private final static String LAST= ",LAST";
private final static String MORE= ",MORE";
private final static String NONE= "NONE";
private final static String NECT= "00 - NECT";
private final static String ECT1= "01 - ECT1";
private final static String ECT0= "10 - ECT0";
private final static String CE= "11 - CE";
private final static String FRM= "Frame Type";
private final static String IP= "IP";
private final static String DSCP= "DSCP";
private final static String ECN= "ECN";
private final static String LEN= "Length";
private final static String PROT= "Protocol";
private final static String DGID= "DataGram ID";
private final static String SRC= "Src Addr";
private final static String DST= "Dest Addr";
private final static String FRAGFLAG= "Fragment Flags";
private final static String IPOPT= "IP Options";
/**
* Base constructor which creates a IPv4 Header.
* @param data BitBuf which represents this header's raw data.
* @see Header
*/
IP4Header(BitBuf data) {
super(data);
type= IP4;
}
public int getHeaderLen() {
if (internetheaderl == null) {
internetheaderl= new Dec(rawheader.slice(4, 4));
}
return Integer.parseInt(internetheaderl.toString()) * 32;
}
public Header getNextHeader() {
return Header.createHeader(rawheader.slice(72, 8).toByte(), rawpayload);
}
/**
* Returns a printable representation of this header.
* @param filter FormatProperties object for filtering this header.
* @return Returns a string representation of this header.
*/
public String toString(FormatProperties filter) {
String protocols= protocol.toString(), flag= "";
// Make sure we have enough data to parse a full header
if (rawheader.getBitSize() < getHeaderLen()) {
return (new Data(rawheader)).toString();
}
// Check for IP filtering
if (filter!=null) { // If filter is enabled
boolean print= false;
String IPaddr= filter.getIPAddress(),
IPaddr2= filter.getSecondIPAddress();
if (IPaddr == null && IPaddr2 == null) {
print= true; // The filtering doesn't apply to this part of the header
} else if(IPaddr==null) {
// If either address matches we print this record
if (src.toString().equals(IPaddr2) || dst.toString().equals(IPaddr2)) {
print= true;
}
} else if (IPaddr.indexOf(':') != -1 ) {
print= true; // IPv6 Address so don't bother to try and filter ia
// If only one address is specified.
} else if (IPaddr2 == null) {
// If either address matches we print this record
if (src.toString().equals(IPaddr) || dst.toString().equals(IPaddr)) {
print= true;
}
// Both addresses were specified
// The packet must match both addresses in any order before its
// printed
} else if (
(src.toString().equals(IPaddr) || src.toString().equals(IPaddr2))
&& (dst.toString().equals(IPaddr) || dst.toString().equals(IPaddr2))) {
print= true;
}
if (!print) { // Don't print the packet
if (Trace.isTraceOn() && Trace.isTraceInformationOn()) {
Trace.log(Trace.INFORMATION,CLASS + ".toString() " + "Frame doesn't pass IP filter");
}
return ""; // Return empty record because it didn't pass the filter
}
}
char[] flagss= (this.flag.toString()).toCharArray();
char[] flagss2= (this.flag2.toString()).toCharArray();
// Convert protocol from number into readable text
if (protocols.equals("0")) {
protocols= RES;
} else if (protocols.equals("1")) {
protocols= ICMP;
} else if (protocols.equals("2")) {
protocols= IGMP;
} else if (protocols.equals("6")) {
protocols= TCP;
} else if (protocols.equals("17")) {
protocols= UDP;
} else if (protocols.equals("41")) {
protocols= IPV6;
} else if (protocols.equals("01")) {
protocols= ICMP;
} else if (protocols.equals("255")) {
protocols= RES;
} else {
protocols= UNK;
}
// Flags as defined in RFC 760
switch (flagss.length) {
case 1 :
if (flagss[0] == '0') {
flag= MAY;
} else {
flag= DONT;
}
break;
case 2 :
if (flagss[0] == '0' && flagss[1] == '0') {
flag= MAY;
} else {
flag= DONT;
}
break;
default :
break;
}
switch (flagss2.length) {
case 1 :
if (flagss2[0] == '0') {
flag += LAST;
} else {
flag += MORE;
}
break;
case 2 :
if (flagss2[0] == '0' && flagss2[1] == '0') {
flag += LAST;
} else {
flag += MORE;
}
break;
default :
break;
}
Object[] args=
{ totallength, identification, flag, protocols, src, dst, options, dscp, ecn };
if ((options.toString()).equals("0x")) {
args[6]= NONE;
}
if (Integer.parseInt(dscp.toString()) == 0x00) {
args[7]= "0";
}
switch (Integer.parseInt(ecn.toString())) {
case 0 :
args[8]= NECT;
break;
case 1 :
args[8]= ECT1;
break;
case 2 :
args[8]= ECT0;
break;
case 3 :
args[8]= CE;
break;
}
String next= printnext(filter);
if (next == "") { // The header didn't pass the filter
return "";
} else {
return Formatter.jsprintf(
"\t "
+ FRM
+ " : "
+ IP
+ " "
+ "\t\t"
+ DSCP
+ ": {7,2,L} "
+ ECN
+ ": {8,10,L} "
+ LEN
+ ": {0,4,L} Protocol: {3,10,L} DataGram ID: {1,6,L}\n"
+ "\t\t\t "
+ SRC
+ ": {4,15,L} "
+ DST
+ ": {5,15,L} "
+ FRAGFLAG
+ ": {2,10,L}\n"
+ "\t "
+ IPOPT
+ " : {6,80,L}\n",
args)
+ printHexHeader()
+ next;
}
}
/**
* Returns the version of this IPv4 Header.
* @return String containing a decimal representation of the version for this header.
*/
public String getVersion() {
return version.toString();
}
/**
* Returns the Internet Header length of this IPv4 Header.
* @return String containing a decimal representation of the header length.
*/
public String getInternetHeaderLength() {
return internetheaderl.toString();
}
/**
* Returns the type of service of this IPv4 Header.
* @return String containing a decimal representation of the type of service for this header.
*/
public String getTypeOfService() {
return typeofservice.toString();
}
/**
* Returns the dscp of this IPv4 Header.
* @return String containing a decimal representation of the dscp for this header.
*/
public String getDscp() {
return dscp.toString();
}
/**
* Returns the ecn of this IPv4 Header.
* @return String containing a decimal representation of the ecn for this header.
*/
public String getEcn() {
return ecn.toString();
}
/**
* Returns the total length of this IPv4 Header.
* @return String containing a decimal representation of the total length for this header.
*/
public String getTotalLength() {
return totallength.toString();
}
/**
* Returns the indentification of this IPv4 Header.
* @return String containing a decimal representation of the identification for this header.
*/
public String getIdentification() {
return identification.toString();
}
/**
* Returns the first flag of this IPv4 Header.
* @return String containing a decimal representation of the flag.
*/
public String getFlag() {
return flag.toString();
}
/**
* Returns the second flag of this IPv4 Header.
* @return String containing a decimal representation of the flag.
*/
public String getFlag2() {
return flag2.toString();
}
/**
* Returns the fragment offset of this IPv4 Header.
* @return String containing a decimal representation of the fragment offest for this header.
*/
public String getFragmentOffset() {
return fragmentoffset.toString();
}
/**
* Returns the time to live of this IPv4 Header.
* @return String containing a decimal representation of the time to live for this header.
*/
public String getTimeToLive() {
return timetolive.toString();
}
/**
* Returns the protocol of this IPv4 Header.
* @return String containing a decimal representation of the protocol for this header.
*/
public String getProtocol() {
return protocol.toString();
}
/**
* Returns the header check sum.
* @return String containing a decimal representation of the header check sum.
*/
public String getHeaderChecksum() {
return headerchecksum.toString();
}
/**
* Returns the source IP address of this IPv4 Header.
* @return String containing a delimited decimal representation of the source IP address.
*/
public String getSrcAddr() {
return src.toString();
}
/**
* Returns the destination IP address of this IPv4 Header.
* @return String containing a delimited decimal representation of the destination IP address.
*/
public String getDstAddr() {
return dst.toString();
}
/**
* Returns the option of this IPv4 header.
* @return String containing a decimal representation of the options.
*/
public String getOptions() {
return (new Dec(options.getData())).toString();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy