src.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-jdk6 Show documentation
Show all versions of jt400-jdk6 Show documentation
The Open Source version of the IBM Toolbox for Java
///////////////////////////////////////////////////////////////////////////////
//
// 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();
}
}