Commit 7654d4a8 authored by garciay's avatar garciay
Browse files

Create Pcap dump tool on file

parent 760ed80a
package org.etsi.common;
import java.nio.ByteOrder;
public class ByteHelper {
public static byte[] changeEndianness(byte [] in) {
byte[] out = new byte[in.length];
for(int i=0; i < in.length; i++) {
out[in.length - i -1] = in[i];
}
return out;
}
public static byte[] intToByteArray(int value, int length, ByteOrder byteOrder) {
if(byteOrder == ByteOrder.LITTLE_ENDIAN) {
return changeEndianness(intToByteArray(value, length));
}
return intToByteArray(value, length);
}
public static byte[] intToByteArray(int value, int length) {
byte[] b = new byte[length];
for (int i = length - 1; i >= 0; i--) {
int offset = (b.length - 1 - i) * 8;
b[i] = (byte) ((value >>> offset) & 0xFF);
}
return b;
}
public static byte[] longToByteArray(long value, int length, ByteOrder byteOrder) {
if(byteOrder == ByteOrder.LITTLE_ENDIAN) {
return changeEndianness(longToByteArray(value, length));
}
return longToByteArray(value, length);
}
public static byte[] longToByteArray(long value, int length) {
byte[] b = new byte[length];
for (int i = length - 1; i >= 0; i--) {
int offset = (b.length - 1 - i) * 8;
b[i] = (byte) ((value >>> offset) & 0xFF);
}
return b;
}
/** Convert a byte array into a boolean
*
* @param b The byte array to convert
* @return The boolean value on success, false otherwise
*/
public static Boolean byteArrayToBoolean(byte[] b) {
// Sanity check
if ((b == null) || (b.length != 1)) {
return null;
}
return new Boolean(b[0] == 0x01);
} // End of method byteArrayToBoolean
public static Short byteArrayToShort(final byte[] b, ByteOrder byteOrder) {
if(byteOrder == ByteOrder.LITTLE_ENDIAN) {
return byteArrayToShort(changeEndianness(b));
}
return byteArrayToShort(b);
}
/** Convert a byte array into a short value assuming that the first byte is the most significant
*
* @param b The byte array to convert
* @return The short value on success, 'Integer.MAX_VALUE' otherwise
*/
public static Short byteArrayToShort(final byte[] b) {
// Sanity check
if ((b == null) || ((b.length * Byte.SIZE) > Short.SIZE)) {
return Short.MAX_VALUE;
}
short value = 0;
for (Short i = 0; i < b.length; i++) {
value = (short)((value << 8) + (b[i] & 0xff));
}
return new Short(value);
} // End of method byteArrayToInt
public static Integer byteArrayToInt(final byte[] b, ByteOrder byteOrder) {
if(byteOrder == ByteOrder.LITTLE_ENDIAN) {
return byteArrayToInt(changeEndianness(b));
}
return byteArrayToInt(b);
}
/** Convert a byte array into an integer assuming that the first byte is the most significant
*
* @param b The byte array to convert
* @return The integer value on success, 'Integer.MAX_VALUE' otherwise
*/
public static Integer byteArrayToInt(final byte[] b) {
// Sanity check
if ((b == null) || ((b.length * Byte.SIZE) > Integer.SIZE)) {
return Integer.MAX_VALUE;
}
int value = 0;
for (int i = 0; i < b.length; i++) {
value = (value << 8) + (b[i] & 0xff);
}
return new Integer(value);
} // End of method byteArrayToInt
public static Long byteArrayToLong(final byte[] b, ByteOrder byteOrder) {
if(byteOrder == ByteOrder.LITTLE_ENDIAN) {
return byteArrayToLong(changeEndianness(b));
}
return byteArrayToLong(b);
}
/** Convert a byte array into a Long assuming that the first byte is the most significant
*
* @param b The byte array to convert
* @return The Long value on success, 'Long.MAX_VALUE' otherwise
*/
public static Long byteArrayToLong(final byte[] b) {
// Sanity check
if ((b == null) || ((b.length * Byte.SIZE) > Long.SIZE)) {
return Long.MAX_VALUE;
}
long value = 0;
for (int i = 0; i < b.length; i++) {
value = (value << 8) + (b[i] & 0xff);
}
return new Long(value);
} // End of method byteArrayToLong
public static byte[] hexStringToByteArray(final String s) {
String str = "";
for(String ss : s.split("[^0-9A-Fa-f]")) {
str = str + ss;
}
int len = str.length();
byte[] data = new byte[len / 2];
for (int i = 0; i < len; i += 2) {
data[i / 2] = (byte) ((Character.digit(str.charAt(i), 16) << 4)
+ Character.digit(str.charAt(i+1), 16));
}
return data;
}
public static byte[] concat(byte[]... arrays) {
int length = 0;
for (byte[] array : arrays) {
if(array != null) {
length += array.length;
}
}
byte[] result = new byte[length];
int position = 0;
for (byte[] array : arrays) {
if(array != null) {
System.arraycopy(array, 0, result, position, array.length);
position += array.length;
}
}
return result;
}
/** Extract a sub part of a byte array
* @param array The original array
* @param offset The offset to start the extract operation
* @param length The number of bytes to extract
* @return The sub part of a provided byte array
*/
public static byte[] extract(final byte[] array, final int offset, final int length) {
// Sanity check
if ((array == null) || (array.length == 0) || (offset > array.length)) {
return null;
}
byte[] result = new byte[length];
System.arraycopy(array, offset, result, 0, length);
return result;
}
/**
* This method convert a byte array containing the couple (length + string) into a string
* @param b The byte array to convert
* @return A string value
*/
public static String byteArrayWithLengthToString(final byte[] b) {
// Sanity check
if (b == null) {
return null;
} else if (b.length == 0) {
return "";
}
// Extract the length of the string
int length = byteArrayToInt(extract(b, 0, 4));
// Extract the the string
String result = "";
for (int i = 0; i < length; i++) {
result += (char)(b[4 + i]);
} // End of 'for' statement
return result;
}
public static String byteArrayToString(final byte[] buffer) {
String result = "";
if (buffer != null) {
for(int i=0; i < buffer.length; ++i) {
result += String.format("%02X", (byte)buffer[i]);
}
}
return result;
}
/**
* Dump a byte array in hex/ascii mode.
* @param label The dump label
* @param buffer The byte array to dump
*/
public synchronized static void dump(final String label, final byte[] buffer)
{
if ((buffer != null) && (buffer.length != 0))
{
System.out.println(label);
StringBuilder finalHexLine = new StringBuilder();
StringBuilder finalCharLine = new StringBuilder();
int nCounter = 0;
int nOffset = 0;
// Flush header.
System.out.println(" HEX | 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F : 0 1 2 3 4 5 6 7 8 9 A B C D E F ");
System.out.println("-----|+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-:--+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
for (int i = 0; i < buffer.length; ++i)
{
byte c = (byte)buffer[i];
String fmtHex = String.format("%02x ", c);
String fmtChar = String.format("%c ", Character.isISOControl((char)c) || c < 0 ? '.' : (char)c);
if (nOffset % 16 == 0)
{
finalHexLine.append(String.format("%05x| ", nOffset));
}
finalHexLine.append(fmtHex);
finalCharLine.append(fmtChar);
if (nCounter == 15)
{
// Flush line.
System.out.println(String.format("%s : %s", finalHexLine.toString(), finalCharLine.toString()));
// Reset buffer.
finalHexLine.delete(0, finalHexLine.length());
finalCharLine.delete(0, finalCharLine.length());
nCounter = 0;
}
else
{
nCounter++;
}
nOffset++;
}
if (nCounter < 16)
{
// Pad till 15.
for (int i = nCounter; i < 16; i++)
{
finalHexLine.append(" ");
finalCharLine.append(" ");
}
// Flush line.
System.out.println(String.format("%s : %s", finalHexLine.toString(), finalCharLine.toString()));
}
}
}
}
/**
* @author STF 424_ITS_Test_Platform
* @version $URL$
* $Id$
*/
package org.etsi.common;
/**
* This interface provides mandatory method to be implemented by a Tuple {A, B}
* @param <A> Type of the first member of the Tuple
* @param <B> Type of the second member of the Tuple
*/
public interface ITuple<A, B> {
/** Retrieve the A element of the tuple
* @return the _a
*/
public abstract A getA();
/** Retrieve the B element of the tuple
* @return the _b
*/
public abstract B getB();
}
\ No newline at end of file
/**
* Knuth-Morris-Pratt Algorithm implementation
* @author ETSI / STF481
* @version $URL$
* $Id$
* Credit http://www.fmi.uni-sofia.bg/
*/
package org.etsi.common;
public class KPM {
/**
* Search the data byte array for the first occurrence of the byte array pattern within given boundaries.
* @param data
* @param start First index in data
* @param stop Last index in data so that stop-start = length
* @param pattern What is being searched. '*' can be used as wildcard for "ANY character"
* @return
*/
public static int indexOf( byte[] data, int start, int stop, byte[] pattern) {
if( data == null || pattern == null) return -1;
int[] failure = computeFailure(pattern);
int j = 0;
for( int i = start; i < stop; i++) {
while (j > 0 && ( pattern[j] != '*' && pattern[j] != data[i])) {
j = failure[j - 1];
}
if (pattern[j] == '*' || pattern[j] == data[i]) {
j++;
}
if (j == pattern.length) {
return i - pattern.length + 1;
}
}
return -1;
}
/**
* Computes the failure function using a boot-strapping process,
* where the pattern is matched against itself.
*/
private static int[] computeFailure(byte[] pattern) {
int[] failure = new int[pattern.length];
int j = 0;
for (int i = 1; i < pattern.length; i++) {
while (j>0 && pattern[j] != pattern[i]) {
j = failure[j - 1];
}
if (pattern[j] == pattern[i]) {
j++;
}
failure[i] = j;
}
return failure;
}
} // End of class KPM
\ No newline at end of file
/**
* @author STF 424_ITS_Test_Platform
* @version $URL$
* $Id$
*/
package org.etsi.common;
/**
* This class implements the ITuple interface
* @param <A> Type of the first member of the Tuple
* @param <B> Type of the second member of the Tuple
*/
public class Tuple<A, B> implements ITuple<A, B> {
/**
* A element of the tuple
*/
private A _a;
/**
* B element of the tuple
*/
private B _b;
/**
* Constructor
* @param a The A element of the new tuple
* @param b The B element of the new tuple
*/
public Tuple(A a, B b) {
_a = a;
_b = b;
}
/**
* Retrieve the A element of the tuple
* @return the _a
*/
@Override
public A getA() {
return _a;
}
/**
* Retrieve the B element of the tuple
* @return the _b
*/
@Override
public B getB() {
return _b;
}
}
package org.etsi.its.pcapdump;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Hashtable;
import java.util.Locale;
import java.util.Vector;
/**
* Largely GNU-compatible command-line options parser. Has short (-v) and
* long-form (--verbose) option support, and also allows options with
* associated values (-d 2, --debug 2, --debug=2). Option processing
* can be explicitly terminated by the argument '--'.
*
* @author Steve Purcell
* @version $Revision$
*/
public class CmdLineParser {
/**
* UID
*/
private static final long serialVersionUID = -5690842973330286842L;
/**
* Base class for exceptions that may be thrown when options are parsed
*/
public static abstract class OptionException extends Exception {
OptionException(String msg) { super(msg); }
}
/**
* Thrown when the parsed command-line contains an option that is not
* recognised. <code>getMessage()</code> returns
* an error string suitable for reporting the error to the user (in
* English).
*/
public static class UnknownOptionException extends OptionException {
/**
* UID
*/
private static final long serialVersionUID = -5690842973330286842L;
/**
* Constructor
* @param optionName Option identifier
*/
UnknownOptionException( String optionName ) {
this(optionName, "Unknown option '" + optionName + "'");
}
/**
* Constructor
* @param optionName Option identifier
* @param msg Error message
*/
UnknownOptionException( String optionName, String msg ) {
super(msg);
this.optionName = optionName;
}
/**
* @return the name of the option that was unknown (e.g. "-u")
*/
public String getOptionName() { return this.optionName; }
private String optionName = null;
}
/**
* Thrown when the parsed commandline contains multiple concatenated
* short options, such as -abcd, where one is unknown.
* <code>getMessage()</code> returns an english human-readable error
* string.
* @author Vidar Holen
*/
public static class UnknownSuboptionException extends UnknownOptionException {
/**
* UID
*/
private static final long serialVersionUID = -3886188976129160327L;
private char suboption;
/**
* Constructor
* @param option Option value
* @param suboption Sub-option value
*/
UnknownSuboptionException( String option, char suboption ) {
super(option, "Illegal option: '"+suboption+"' in '"+option+"'");
this.suboption=suboption;
}
/**
* @return The sub-option value
*/
public char getSuboption() { return suboption; }
}
/**
* Thrown when the parsed commandline contains multiple concatenated
* short options, such as -abcd, where one or more requires a value.
* <code>getMessage()</code> returns an english human-readable error
* string.
* @author Vidar Holen
*/
public static class NotFlagException extends UnknownOptionException {
/**
* UID
*/
private static final long serialVersionUID = -5862485101945261269L;
private char notflag;
NotFlagException( String option, char unflaggish ) {
super(option, "Illegal option: '"+option+"', '"+
unflaggish+"' requires a value");
notflag=unflaggish;
}
/**
* @return the first character which wasn't a boolean (e.g 'c')
*/
public char getOptionChar() { return notflag; }
}
/**
* Thrown when an illegal or missing value is given by the user for
* an option that takes a value. <code>getMessage()</code> returns
* an error string suitable for reporting the error to the user (in
* English).
*/
public static class IllegalOptionValueException extends OptionException {
/**
* UID
*/
private static final long serialVersionUID = -3519380930288555047L;
public IllegalOptionValueException( Option opt, String value ) {
super("Illegal value '" + value + "' for option " +
(opt.shortForm() != null ? "-" + opt.shortForm() + "/" : "") +
"--" + opt.longForm());
this.option = opt;
this.value = value;
}
/**
* @return the name of the option whose value was illegal (e.g. "-u")
*/
public Option getOption() { return this.option; }
/**
* @return the illegal value
*/
public String getValue() { return this.value; }
private Option option;
private String value;
}
/**