src.com.ibm.as400.util.commtrace.Frame Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400-jdk9 Show documentation
Show all versions of jt400-jdk9 Show documentation
The Open Source version of the IBM Toolbox for Java
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: Frame.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 java.io.*;
import com.ibm.as400.access.Trace;
import java.util.Properties;
import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
/**
* Encapsulates all the data for one Frame of the trace.
* Parses the Frame data and creates a printable representation of this
* Frame.
* The data in any packet is mainted in a linked list like structure. The
* format of any Frame will be one of the following:
*
* - arp/rarp
* - ip4,tcp
* - ip4,udp
* - ip4,icmp6
* - ip6,tcp
* - ip6,udp
* - ip6,icmp6
* - The next 3 are for tunneled packets
* - ip4,ip6,tcp
* - ip4,ip6,udp
* - ip4,ip6,icmp6
* - ip6,eh,tcp
* - ip6,eh,udp
* - ip6,eh,icmp6
* - The next 3 are for tunneled packets
* - ip4,ip6,eh,tcp
* - ip4,ip6,eh,udp
* - ip4,ip6,eh,icmp6
*
* eh is the extended header
* Note: Every set of headers is followed by the raw data if
* applicable
* The classes in the structure are accessible through the
* Frame.getPacket() and Header.getNextHeader() methods. The type is
* accessible through the Header.getType() method
*/
public class Frame {
private final static String BROADCAST= "0xFFFFFFFFFFFF", CLASS="Frame";
private BitBuf data;
private Prolog pro;
private int frmhdrl, datalen, frmtype, ifshdr= 176;
private IPPacket packet; // The parsed packet of data
private Field IFSRECN, /* Frame number */
IFSRCTD, /* 64 bit TOD */
IFSRECTP, /* Frame type */
IFSPDULN, /* PDU length */
IFSRECST, /* Frame status */
IFSSLT, /* SDLC slot */
IFSPORT, /* SDLC port */
IFSLLC, /* LAN frame is LLC 'FF'x */
IFSRTLN, /* LAN routing length */
IFSTCP; /* Frame is TCP Y/N */
private Time tod_; // The time of this trace
private boolean tcp= true; // If this Frame isn't TCP this field is set
private LanHeader lnHdr; // The 22 byte LAN header
/**
* Creates a Frame which parses the raw data contained in this packet.
* @param pro Prolog to this trace.
* @param data BitBuf with the raw data.
*/
Frame(Prolog pro, BitBuf data) {
this.data= data;
this.pro= pro;
IFSRECN= new Dec(data.slice(0, 16));
IFSRCTD= new Dec(data.slice(16, 64));
IFSRECTP= new Char(data.slice(80, 8));
IFSPDULN= new Dec(data.slice(88, 16));
IFSRECST= new Dec(data.slice(104, 32));
IFSSLT= new Dec(data.slice(136, 8));
IFSPORT= new Dec(data.slice(144, 8));
IFSLLC= new Hex(data.slice(152, 8));
IFSRTLN= new Dec(data.slice(160, 8));
IFSTCP= new Char(data.slice(168, 8));
if (Trace.isTraceOn() && Trace.isTraceInformationOn()) {
Trace.log(
Trace.INFORMATION,
CLASS + ".Frame() " + "Creating Frame " + IFSRECN.toString() + "... tcp:" + IFSTCP.toString());
}
if ((IFSTCP.toString()).equals("Y")) { // If the Frame is TCP parse it
tcp= true;
lnHdr= new LanHeader(data, IFSLLC, pro.getProtocol());
frmhdrl= lnHdr.getDataStart() + ifshdr;
parseIPdata(new BitBuf(data, frmhdrl, (data.getBitSize() - frmhdrl)));
} else {
tcp= false;
}
}
/**
* Parses the IP data of this Frame.
* @param hdr BitBuf with this Frame's IP data.
*/
private void parseIPdata(BitBuf hdr) {
frmtype= lnHdr.getFrameType();
// Create the correct packet based on the Frame type
if (frmtype == 0x86DD) {
packet= new IP6Packet(hdr.getBytes());
packet.setType(IPPacket.IP6);
} else if (frmtype == 0x0800) {
packet= new IP4Packet(hdr.getBytes());
packet.setType(IPPacket.IP4);
} else if (frmtype == 0x0806) {
packet= new ARPPacket(hdr.getBytes(), frmtype);
packet.setType(IPPacket.ARP);
} else if (frmtype == 0x8035) {
packet= new ARPPacket(hdr.getBytes(), frmtype);
packet.setType(IPPacket.RARP);
} else {
if (Trace.isTraceOn() && Trace.isTraceInformationOn()) {
Trace.log(Trace.INFORMATION,CLASS + ".parseIPData() " + "Unknown IPPacket");
}
packet= new UnknownPacket(hdr.getBytes());
packet.setType(IPPacket.UNK);
}
}
/**
* Returns a printable representation of this Frame.
* @param filter FormatProperties object for filtering this Frame.
* @return Returns a string representation of this Frame.
*/
public String toString(FormatProperties filter) {
StringBuffer ret= new StringBuffer(); // The return string
String time;
if (tcp) { // If its not TCP just return
// Create our Time object with the timestamp
if (tod_ == null) {
tod_= new Time(Long.parseLong((IFSRCTD.toString())));
}
// Get a printable time
time= tod_.getTime();
// If user doesn't want broadcast and the Mac address is broadcast
// then just return
if (filter!=null) { // If filter is enabled
boolean print= false;
String broadcast= filter.getBroadcast();
String starttime= filter.getStartTime();
String endtime= filter.getEndTime();
long timestamp= tod_.getTimeStamp();
if (starttime == null
&& endtime == null) {
// The filter doesn't apply to the two filters for this Frame we will continue on
print= true;
} else if (
starttime != null && endtime == null) { // A start time but no end time
// Timestamp is greater then the start time we print the Frame
if (timestamp >= Long.parseLong(starttime)) {
print= true;
}
} else { // Start and end time both specified
// Timestamp is less then the end time but greater then the start time we print the Frame
if (Long.parseLong(endtime) >= timestamp
&& timestamp >= Long.parseLong(starttime)) {
print= true;
}
}
if (broadcast == null) { // Filtering doesn't apply to the Broadcast
} else if (
broadcast.equals(FormatProperties.NO)
&& (lnHdr.getMacAddress()).equals(
BROADCAST)) { // If the packet is broadcast don't print it
print= false;
}
if (!print) { // Don't print the packet
if (Trace.isTraceOn() && Trace.isTraceInformationOn()) {
Trace.log(Trace.INFORMATION,CLASS + ".toString() " + "Frame doesn't pass filters. Not printing");
}
return "";
}
}
Object[] args=
{
IFSRECN,
IFSRECTP,
new Integer(Integer.parseInt(IFSPDULN.toString()) - (lnHdr.getDataStart() / 8)),
// Calculate the data length
time };
// Add the Frame data
ret.append(
(Formatter
.jsprintf(
"{0,6,R}" + "{1,5,R}" + "{2,8,R}" + "{3,16,R}" + lnHdr.toString(),
args)));
if ((pro.getProtocol()).equals("E")) { // Token Ring?
ret.append(lnHdr.printRoutingData()); // Append the Routing data
}
String returnpacket= packet.toString(filter);
if (returnpacket.equals("")) {
// The packet wasn't printed so return an empty Frame
return "";
} else { // Append the packet
ret.append(returnpacket);
}
// If there is data that wasn't traced append the amount to the
// end of the Frame
int notTraced= Integer.parseInt(IFSPDULN.toString()) - data.getByteSize() + 22;
if (notTraced > 0) {
ret.append(
"\t\t\t * * * * * * * * * * * * * * "
+ notTraced
+ " BYTES OF DATA NOT TRACED "
+ "* * * * * * * * * * * * * *\n");
}
return ret.toString();
} else {
return "";
}
}
/**
* Returns the packet contained by this Frame.
* @return IPPacket this packet.
*/
public IPPacket getPacket() {
return packet;
}
/**
* Returns the Frame number.
* @return String containing the Frame number.
*/
public String getRecNum() {
return IFSRECN.toString();
}
/**
* Returns 64 bit Time of Day.
* @return String containing the TOD.
*/
public String getTOD() {
return IFSRCTD.toString();
}
/**
* Return the Time of day in HH:MM:SS.mm format.
* @return String containing the Time.
*/
public String getTime() {
if (tod_ == null) {
tod_= new Time(Long.parseLong((IFSRCTD.toString())));
}
// Get a printable time
return tod_.getTime();
}
/**
* Returns the Frame type.
* @return String containing the Frame type.
*/
public String getRecType() {
return IFSRECTP.toString();
}
/**
* Returns the PDU length.
* @return String containing the PDU length.
*/
public String getPDUType() {
return IFSPDULN.toString();
}
/**
* Returns the Frame status.
* @return String containing the Frame status.
*/
public String getRecStatus() {
return IFSRECST.toString();
}
/**
* Returns the SDLC slot.
* @return String containing the SDLC slot.
*/
public String getSDLCSlot() {
return IFSSLT.toString();
}
/**
* Returns the SDLC port.
* @return String containing the SDLC port.
*/
public String getSDLCPort() {
return IFSPORT.toString();
}
/**
* Returns the code determining if the LAN fame is LLC.
* 0xFF = LLC
* @return String containing the code,
*/
public String getLLC() {
return IFSLLC.toString();
}
/**
* Returns the LAN routing length,
* @return String containing the LAN routing length,
*/
public String getRoutingLength() {
return IFSRTLN.toString();
}
/**
* Returns if the Frame is TCP Y/N.
* @return String containing Y or N.
*/
public String getTCP() {
return IFSTCP.toString();
}
/**
* Returns a boolean indicating if the Frame is TCP
* @return true if Frame is TCP.
*/
public boolean isTCP() {
return tcp;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy