Create Pcap dump tool on file

tools/pcapdump/src/org/etsi/common/ByteHelper.java

+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()));
+            }
+        }
+    }
+}

tools/pcapdump/src/org/etsi/common/ITuple.java

+/**
+ * @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

tools/pcapdump/src/org/etsi/common/KPM.java

+/**
+ *  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

tools/pcapdump/src/org/etsi/common/Tuple.java

+/**
+ * @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;
+	}
+}

tools/pcapdump/src/org/etsi/its/pcapdump/CmdLineParser.java

+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; }
+
+        /**