Example usage for org.apache.commons.io HexDump dump

List of usage examples for org.apache.commons.io HexDump dump

Introduction

In this page you can find the example usage for org.apache.commons.io HexDump dump.

Prototype


public static void dump(byte[] data, long offset, OutputStream stream, int index)
        throws IOException, ArrayIndexOutOfBoundsException, IllegalArgumentException 

Source Link

Document

Dump an array of bytes to an OutputStream.

Usage

From source file:org.jopenray.server.thinclient.DisplayReaderThread.java

private void handlePacket(byte[] udpData, int l) {
    boolean dump = false;
    ByteArrayInputStream bIn = new ByteArrayInputStream(udpData, 0, l);
    int r = readInt16(bIn);
    int flag = readInt16(bIn);
    int type = readInt16(bIn);
    int dir = readInt16(bIn);
    if (DEBUG)/*from  w ww  . j  a v a 2  s  . c  o m*/
        System.out.print("Seq number:" + r + " Flag:" + flag + " Type:" + type + " Dir:" + dir);

    // Sunray ->Server
    int a = readInt16(bIn);
    int b = readInt16(bIn);
    int c = readInt16(bIn);
    int d = readInt16(bIn);
    if (DEBUG)
        System.out.println("Sunray -> Server:" + a + "," + b + "," + c + "," + d);
    if (bIn.available() == 0) {
        DisplayMessage m = new DisplayMessage(client.getWriter());
        m.addOperation(new PadOperation());
        this.client.getWriter().addMessage(m);
    } else
        while (bIn.available() > 0) {
            int opcode = bIn.read();
            int hdat = readInt16(bIn);
            int idat = bIn.read();
            String opCodeHeader = "";

            opCodeHeader += "[ Opcode: " + opcode + " , " + hdat + " ," + idat + " ]";

            switch (opcode) {
            case 0xc1:
                dump = true;
                int jdat = readInt16(bIn);
                int modifier = readInt16(bIn);
                // 6 octet
                int key1 = bIn.read();
                int key2 = bIn.read();
                int key3 = bIn.read();
                int key4 = bIn.read();
                int key5 = bIn.read();
                int key6 = bIn.read();

                //
                int mdat = readInt16(bIn);
                System.out.println("Keyboard " + opCodeHeader + " " + jdat + " modifier:" + modifier + " keys:("
                        + key1 + "," + key2 + "," + key3 + "," + key4 + "," + key5 + "," + key6 + ") " + mdat);

                /*
                 * if(lastPressed>0){
                 * System.out.println("Send Key Released:"+lastPressed);
                 * sendKeyReleased(lastPressed); lastPressed=-1; }
                 */

                if (key1 > 0) {
                    if (!keysPressed.contains(key1)) {

                        int hidToKeyCode = HID.hidToKeyCode(key1);
                        System.out.println(modifier + " : " + (modifier & 0x2));
                        sendKeyPressed(hidToKeyCode, (modifier & 2) != 0 || (modifier & 32) != 0,
                                (modifier & 1) != 0, (modifier & 4) != 0, (modifier & 8) != 0,
                                (modifier & 64) != 0);
                        keysPressed.add(key1);
                    }

                } else {
                    for (int i = 0; i < this.keysPressed.size(); i++) {
                        int k = keysPressed.get(i);
                        int hidToKeyCode = HID.hidToKeyCode(k);
                        sendKeyReleased(hidToKeyCode);

                    }
                    keysPressed.clear();
                }

                break;
            case 0xc2:
                int buttons = readInt16(bIn);
                int mouseX = readInt16(bIn);
                int mouseY = readInt16(bIn);
                int c2 = readInt16(bIn);
                if (DEBUG)
                    System.out.println("Mouse" + opCodeHeader + " buttons:" + buttons + " (" + mouseX + ","
                            + mouseY + ")" + c2);
                processMouseEvent(buttons, mouseX, mouseY);
                break;
            case 0xc4: {
                int c41 = readInt32(bIn);
                int c42 = readInt32(bIn);
                int c43 = readInt32(bIn);

                System.out.println("NACK  seq= " + c41 + "  type: " + c42 + " , " + c43);
                client.resend(c42, c43);
                break;
            }
            case 0xc5:
                int c51 = bIn.read();
                int c52 = bIn.read();
                int c53 = bIn.read();
                int c54 = bIn.read();

                System.out.println("0xC5 " + opCodeHeader + " " + c51 + "," + c52 + "," + c53 + "," + c54);
                break;
            case 0xc6:
                int dataLength = readInt16(bIn);
                int stringLength = bIn.read();
                byte[] string = new byte[stringLength];

                try {
                    int rL = bIn.read(string);
                    System.out.println(dataLength + " , " + stringLength + " readLength" + rL);
                    System.out.println("Firmware: " + new String(string));
                    // dump = true;
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                break;

            case 0xc7: {
                int x1 = readInt16(bIn);
                int y1 = readInt16(bIn);
                int w1 = readInt16(bIn);
                int h1 = readInt16(bIn);
                int x2 = readInt16(bIn);
                int y2 = readInt16(bIn);
                int w2 = readInt16(bIn);
                int h2 = readInt16(bIn);
                int x3 = readInt16(bIn);
                int y3 = readInt16(bIn);
                int w3 = readInt16(bIn);
                int h3 = readInt16(bIn);
                if (DEBUG)
                    System.out.println("Rect: " + opCodeHeader + " [" + x1 + "," + y1 + "," + w1 + "," + h1
                            + "][" + x2 + "," + y2 + "," + w2 + "," + h2 + "][" + x3 + "," + y3 + "," + w3 + ","
                            + h3 + "]");

                break;
            }
            case 0xcb:
                int bc1 = bIn.read();
                int bc2 = readInt16(bIn);
                int bc3 = readInt16(bIn);
                int bc4 = readInt16(bIn);
                int bc5 = readInt16(bIn);
                int bc6 = readInt16(bIn);
                int bc7 = readInt16(bIn);
                int bc8 = readInt16(bIn);
                int bc9 = readInt16(bIn);
                int bc10 = readInt16(bIn);
                int bc11 = readInt16(bIn);
                if (DEBUG)
                    System.out.println(
                            "0xCB " + opCodeHeader + " " + bc1 + "," + bc2 + "," + bc3 + "," + bc4 + "," + bc5
                                    + "," + bc6 + "," + bc7 + "," + bc8 + "," + bc9 + "," + bc10 + "," + bc11);
                break;
            default:
                System.out.println("Unknown opcode: " + opCodeHeader);
                dump = true;
                break;
            }
        }
    if (dump) {
        try {
            HexDump.dump(udpData, 0, System.err, 0);
        } catch (Exception ignr) {
        }
    }

}

From source file:org.jopenray.test.ByteArrayListWithHeaderTest.java

@Test
public void testSetInt16() {
    byte[] a = new byte[] { 10, 20 };
    ByteArrayListWithHeader l2 = new ByteArrayListWithHeader(5, 2);
    for (int i = 0; i < 10; i++) {
        l2.addBytes(a);/* w w w .j av  a  2 s.c  om*/
    }
    for (int i = 0; i < 10; i++) {
        l2.setInt16(2 * i, i);
    }
    try {
        HexDump.dump(l2.getInnerByteBuffer(), 0, System.err, 0);
    } catch (Exception ignr) {
    }

    assertArrayEquals(new byte[] { 0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 0, 10, 20, 10,
            0, 0, 20, 10, 20, 0, 0, 10, 20 }, l2.getBytes());
}

From source file:org.jopenray.util.PacketAnalyser.java

public static void decode(PrintStream out, byte[] udpData) throws IOException {
    boolean dump = false;
    ByteArrayInputStream bIn = new ByteArrayInputStream(udpData);
    int r = readInt16(bIn);
    if (r == 1) {
        out.println("===================================================================================");
    }/*  w ww .  j a  va2 s  . c  om*/
    out.print("Seq number:" + r);
    int flag = readInt16(bIn);
    out.print(" Flag:" + flag);
    int type = readInt16(bIn);
    out.print(" Type:" + type);
    int dir = readInt16(bIn);
    out.println(" Dir:" + dir + " dataSize:" + udpData.length);
    if (dir == 0) {
        // Server -> Sunray
        int a = readInt16(bIn);
        int b = readInt16(bIn);
        int c = readInt16(bIn);
        int d = readInt16(bIn);
        out.println("Server -> Sunray:" + a + "," + b + "," + c + "," + d);

        while (bIn.available() > 0) {
            String opCodeHeader = "";
            int opcode = bIn.read();
            opCodeHeader += "[ Opcode: " + opcode;
            int f = bIn.read();
            opCodeHeader += " Flag" + f;
            int oseq = readInt16(bIn);
            opCodeHeader += " OpcodeSeq:" + oseq;
            int x = readInt16(bIn);
            int y = readInt16(bIn);

            int w = readInt16(bIn);
            int h = readInt16(bIn);

            opCodeHeader += " x,y: " + x + "," + y + " w:" + w + " h:" + h + " ]";
            if (opcode != 0xB1) {
                return;
            }
            switch (opcode) {
            case 0x03:
                out.println("0x03 Strange opcode " + opCodeHeader);
                break;
            case 0xA1:
                int ap1 = bIn.read();
                int ap2 = bIn.read();
                int ap3 = bIn.read();
                int ap4 = bIn.read();
                out.println("0xA1:" + ap1 + "," + ap2 + "," + ap3 + "," + ap4 + opCodeHeader);
                break;
            case 0xA2:
                // out.println("FillRect");
                int a2p1 = bIn.read();
                int a2p2 = bIn.read();
                int a2p3 = bIn.read();
                int a2p4 = bIn.read();
                out.println("FillRect: Color:" + a2p1 + "," + a2p2 + "," + a2p3 + "," + a2p4 + opCodeHeader);
                break;
            case 0xA3: {

                int a3p1 = bIn.read();
                int a3p2 = bIn.read();
                int a3p3 = bIn.read();
                int a3p4 = bIn.read();
                int nbBytesPerRow = round(w, 8) / 8;
                int nbBytes = round(nbBytesPerRow * h, 4);
                byte[] unkuonw = new byte[nbBytes];
                try {
                    int lRead = bIn.read(unkuonw);
                    out.println("FillRectBitmap: Color:" + a3p1 + "," + a3p2 + "," + a3p3 + "," + a3p4
                            + " | bytes/row:" + nbBytesPerRow + "l:" + nbBytes + " lRead:" + lRead
                            + opCodeHeader);

                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                break;
            }
            case 0xA4:
                int xsrc = readInt16(bIn);
                int ysrc = readInt16(bIn);
                out.println("CopyRect from : " + xsrc + "," + ysrc + opCodeHeader);

                break;
            case 0xA5: {
                // out.println("SetRectBitmap");
                // err.println("SetRectBitmap not yet implemented");
                try {
                    Color c1 = readColor(bIn);
                    Color c2 = readColor(bIn);
                    int nbBytesPerRow = round(w, 8) / 8;
                    int nbBytes = round(nbBytesPerRow * h, 4);
                    byte[] unkuonw = new byte[nbBytes];

                    int lRead = bIn.read(unkuonw);

                    out.println("SetRectBitmap: " + w + "x" + h + " at " + x + "," + y + " Color:" + c1 + " / "
                            + c2 + " | bytes/row:" + nbBytesPerRow + " l:" + nbBytes + " lRead:" + lRead
                            + opCodeHeader);
                    if (nbBytes > 1024) {
                        out.println("! data too long:" + nbBytes);
                    } else {
                        HexDump.dump(unkuonw, 0, System.err, 0);
                    }
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    dump = true;
                }

                break;
            }
            case 0xA6: {

                out.println("SetRect:" + opCodeHeader);
                int nbBytesPerRow = round(w * 3, 4);
                int nbBytes = round(nbBytesPerRow * h, 4);
                // int nbBytes=w*h;
                if (nbBytes > 1000000) {
                    System.out.println("Bad length:" + nbBytes);
                } else {
                    byte[] colors = new byte[nbBytes];

                    int lRead = bIn.read(colors);
                    if (lRead != nbBytes) {
                        System.out.println("Bad length:" + nbBytes + " != " + lRead);
                    }
                    // colors contains colors (r,g,b)
                }
                break;
            }
            case 0xA8: {
                int xbound = readInt16(bIn);
                int ybound = readInt16(bIn);
                int wbound = readInt16(bIn);
                int hbound = readInt16(bIn);
                out.println("SetMouseBound to: " + xbound + "," + ybound + " w:" + wbound + " h:" + hbound + " "
                        + opCodeHeader + opCodeHeader);

                break;
            }
            case 0xA9: {

                Color c1 = readColor(bIn);
                Color c2 = readColor(bIn);
                out.println("SetMousePointer pos:" + x + "," + y + " size:" + w + "x" + h + " Color:" + c1
                        + " , " + c2 + opCodeHeader);
                int l = (w * h) / 8;
                byte[] b1 = new byte[l];
                bIn.read(b1);
                out.println("Bitmap");
                // printBits(w, h, b1);

                byte[] b2 = new byte[l];
                bIn.read(b2);
                out.println("Mask");
                // printBits(w, h, b2);
                break;
            }
            case 0xAA:
                int aap1 = bIn.read();
                int aap2 = bIn.read();
                int aap3 = bIn.read();
                int aap4 = bIn.read();
                out.println("SetMousePosition: " + aap1 + "," + aap2 + "," + aap3 + "," + aap4 + opCodeHeader);
                break;
            case 0xAB:
                int ab1 = readInt16(bIn);
                int ab2 = readInt16(bIn);
                out.println("SetKeyLock: " + ab1 + " " + ab2 + opCodeHeader);

                break;
            case 0xAC:

                int ac1 = readInt16(bIn);
                int ac2 = readInt16(bIn);
                int ac3 = readInt16(bIn);
                int ac4 = readInt16(bIn);
                out.println(
                        "0xAC : " + ac1 + " , " + ac2 + "," + ac3 + " , " + ac4 + opCodeHeader + opCodeHeader);
                break;
            case 0xAD:
                out.println("0xAD" + opCodeHeader);

                int l = readInt16(bIn);
                // l = (l & 0xfffc) + 2;

                out.println("l: " + l);
                out.println("(l & 0xfffc) + 2 :" + (l & 0xfffc) + 2);
                byte[] unkuonwn = new byte[l];
                dump = true;
                try {
                    int lRead = bIn.read(unkuonwn);
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                break;
            case 0xAF: {

                int p1 = bIn.read();
                int p2 = bIn.read();
                int p3 = bIn.read();
                int p4 = bIn.read();
                for (int i = 0; i < 8; i++) {
                    bIn.read();
                }
                if (p1 != 255 && p2 != 255 && p3 != 255 && p4 != 255) {
                    out.println("PAD:" + p1 + "," + p2 + "," + p3 + "," + p4 + opCodeHeader);
                } else {
                    out.println("PAD " + opCodeHeader);
                }
                break;
            }
            case 0xB1:

                out.println("AUDIO:" + r + "|" + flag + "|" + type + "|" + dir + " l:" + udpData.length + " "
                        + opCodeHeader);
                outTest.print("AUDIO:" + r + "|" + flag + "|" + type + "|" + dir + " " + opCodeHeader);
                /*
                 * int xbound = readInt16(bIn); int ybound = readInt16(bIn);
                 * int wbound = readInt16(bIn); int hbound = readInt16(bIn);
                 * out.println(" to: " + xbound + "," + ybound + " w:" +
                 * wbound + " h:" + hbound + " " + opCodeHeader +
                 * opCodeHeader); dump=true;
                 */

                int v1 = 0;
                int v2 = 0;
                int totalv1et2 = 0;
                int bigTotal = 0;
                while (bIn.available() >= 0) {
                    int b1 = bIn.read();
                    int b2 = bIn.read();
                    if (b1 == -1 && b2 == -1) {
                        outTest.print(totalv1et2 + " : big total: " + bigTotal);
                        break;
                    }
                    soundOut.write(b2);
                    soundOut.write(b1);

                    if (b1 == 0x7F && b2 == 0xFF) {
                        v1++;
                        bigTotal++;
                        totalv1et2++;
                        if (v2 > 0)
                            out.println("v2=" + v2);
                        v2 = 0;
                    } else if (b1 == 0x80 && b2 == 0x01) {
                        v2++;
                        totalv1et2++;
                        bigTotal++;
                        if (v1 > 0)
                            out.println("v1=" + v1);
                        v1 = 0;
                    } else {
                        if (v2 > 0)
                            out.println("v2=" + v2);
                        if (v1 > 0)
                            out.println("v1=" + v1);
                        out.println("Unknwon:" + b1 + " et " + b2 + "[" + (b1 * 256 + b2) + "] total v1+v2:"
                                + totalv1et2);
                        if (totalv1et2 > 0)
                            outTest.print(totalv1et2 + ",");
                        v1 = 0;
                        v2 = 0;
                        totalv1et2 = 0;
                    }
                    /*
                     * bIn.read(); bIn.read(); for (int j = 0; j < 8; j++) {
                     * for (int i = 0; i < 12; i++) {
                     * 
                     * int aaa1 = bIn.read(); int aaa2 = bIn.read(); if (i %
                     * 2 == 0) { soundOut.write(aaa2); soundOut.write(aaa1);
                     * } } }
                     */

                }
                outTest.println();

                break;
            case 0xD1:
                out.println("0xD1 " + opCodeHeader + opCodeHeader);
                break;
            case 0xD8:
                out.println("0xD8 " + opCodeHeader + opCodeHeader);
                break;
            case 0xB0: {
                out.println("0xB0 " + opCodeHeader + opCodeHeader);
                int p1 = readInt16(bIn);

                int p2 = readInt16(bIn);
                int p3 = readInt16(bIn);
                int nb = readInt16(bIn);
                out.println(p1 + " ; " + p2 + " ; " + p3);
                for (int i = 0; i < nb; i++) {
                    int xx = readInt16(bIn);
                    int yy = readInt16(bIn);
                    int ww = readInt16(bIn);
                    int hh = readInt16(bIn);
                    out.println("[" + xx + "," + yy + " " + ww + "x" + hh + "]");
                }
                break;
            }
            case 0xB4: {
                // ??
                out.println("0xB4 " + opCodeHeader + opCodeHeader);

                for (int i = 0; i < 19; i++) {
                    int p1 = readInt16(bIn);
                    out.print(p1 + ",");
                }
                int end = readInt16(bIn);
                out.println(end);
                break;
            }
            case 0xB9: {
                // ??
                out.println("0xB9 " + opCodeHeader + opCodeHeader);
                break;
            }
            case 0xBF: {
                int le = readInt16(bIn);
                out.println("0xBF " + le + " bytes " + opCodeHeader);

                byte[] unknown = new byte[le];

                try {
                    int lRead = bIn.read(unknown);
                    if (lRead != le) {
                        out.println("Bad length:" + lRead + " / " + le);
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                break;
            }
            default:
                out.println("Unknown opcode:" + opcode + opCodeHeader);
                dump = true;
                break;
            }
        }
    } else if (dir == 2000) {

        // Sunray -> Server
        int a = readInt16(bIn);
        int b = readInt16(bIn);
        int c = readInt16(bIn);
        int d = readInt16(bIn);
        out.println("Sunray -> Server:" + a + "," + b + "," + c + "," + d);

        while (bIn.available() > 0) {
            int opcode = bIn.read();
            int hdat = readInt16(bIn);
            int idat = bIn.read();
            String opCodeHeader = "";

            opCodeHeader += "[ Opcode: " + opcode + " , " + hdat + " ," + idat + " ]";
            switch (opcode) {
            case 0:
                out.println("Empty (keep alive?)");
                break;
            case 0xc1:

                int jdat = readInt16(bIn);
                int shift = readInt16(bIn);
                // 6 octet
                int key1 = bIn.read();
                int key2 = bIn.read();
                int key3 = bIn.read();
                int key4 = bIn.read();
                int key5 = bIn.read();
                int key6 = bIn.read();

                //
                int mdat = readInt16(bIn);
                out.println("Keyboard " + opCodeHeader + " " + jdat + " shift:" + shift + " keys:(" + key1 + ","
                        + key2 + "," + key3 + "," + key4 + "," + key5 + "," + key6 + ") " + mdat);
                break;
            case 0xc2:
                int buttons = readInt16(bIn);
                int mouseX = readInt16(bIn);
                int mouseY = readInt16(bIn);
                int c2 = readInt16(bIn);
                out.println("Mouse" + opCodeHeader + " buttons:" + buttons + " (" + mouseX + "," + mouseY + ")"
                        + c2);
                break;
            case 0xc4:
                int c41 = readInt32(bIn);
                int c42 = readInt32(bIn);
                int c43 = readInt32(bIn);

                out.println("NACK " + c41 + "," + c42 + "," + c43);

                break;
            case 0xc5:
                int c51 = bIn.read();
                int c52 = bIn.read();
                int c53 = bIn.read();
                int c54 = bIn.read();

                out.println("0xC5 " + opCodeHeader + " " + c51 + "," + c52 + "," + c53 + "," + c54);
                break;
            case 0xc6:
                int dataLength = readInt16(bIn);
                int stringLength = bIn.read();
                byte[] string = new byte[stringLength];

                try {
                    int rL = bIn.read(string);
                    out.println(dataLength + " , " + stringLength + " readLength" + rL);
                    out.println("Firmware: " + new String(string));
                    // dump = true;
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                break;
            case 0xc7: {
                int x1 = readInt16(bIn);
                int y1 = readInt16(bIn);
                int w1 = readInt16(bIn);
                int h1 = readInt16(bIn);
                int x2 = readInt16(bIn);
                int y2 = readInt16(bIn);
                int w2 = readInt16(bIn);
                int h2 = readInt16(bIn);
                int x3 = readInt16(bIn);
                int y3 = readInt16(bIn);
                int w3 = readInt16(bIn);
                int h3 = readInt16(bIn);
                out.println("Rect: " + opCodeHeader + " [" + x1 + "," + y1 + "," + w1 + "," + h1 + "][" + x2
                        + "," + y2 + "," + w2 + "," + h2 + "][" + x3 + "," + y3 + "," + w3 + "," + h3 + "]");

                break;

            }
            case 0xCA:
                int ca1 = readInt16(bIn);
                int ca2 = readInt16(bIn);
                int ca3 = readInt16(bIn);
                int ca4 = readInt16(bIn);
                int ca5 = readInt16(bIn);
                int ca6 = readInt16(bIn);

                out.println("0xCA " + opCodeHeader + " " + ca1 + "," + ca2 + "," + ca3 + "," + ca4 + "," + ca5
                        + "," + ca6);
                break;
            case 0xcb:
                int bc1 = bIn.read();
                int bc2 = readInt16(bIn);
                int bc3 = readInt16(bIn);
                int bc4 = readInt16(bIn);
                int bc5 = readInt16(bIn);
                int bc6 = readInt16(bIn);
                int bc7 = readInt16(bIn);
                int bc8 = readInt16(bIn);
                int bc9 = readInt16(bIn);
                int bc10 = readInt16(bIn);
                int bc11 = readInt16(bIn);
                out.println("0xCB " + opCodeHeader + " " + bc1 + "," + bc2 + "," + bc3 + "," + bc4 + "," + bc5
                        + "," + bc6 + "," + bc7 + "," + bc8 + "," + bc9 + "," + bc10 + "," + bc11);
                break;
            default:
                out.println("Unknown opcode: " + opCodeHeader);
                dump = true;
                break;
            }
        }
    } else {
        out.println("Unknown packet direction:" + dir);
        dump = true;
    }
    if (dump) {
        HexDump.dump(udpData, 0, System.err, 0);
    }
}

From source file:org.jopenray.util.PcapFileReader.java

public static void main(String[] args) throws IOException {
    PcapFileReader r = new PcapFileReader(new File("test.pcap"));
    int c = 1;//from w  ww. j  av  a  2s. c  o m
    while (r.hasNext()) {
        System.out.println("Packet:" + c);
        PcapPacket p = r.next();
        System.out.println("isIp:" + p.isIP());
        if (p.isIP()) {
            System.out.println(p.getSourceIp() + ":" + p.getUDPSrcPort() + " -> " + p.getDestIp() + ":"
                    + p.getUDPDstPort());
            System.out.println("isUDP:" + p.isUDP());
            System.out.println("isTCP:" + p.isTCP());
            HexDump.dump(p.getData(), 0, System.out, 0);

        }
        c++;
        if (c > 10)
            System.exit(0);
    }

}

From source file:se.kth.infosys.lumberjack.protocol.LumberjackClient.java

public int sendCompressedFrame(List<Map<String, byte[]>> keyValuesList) throws IOException {
    output.writeByte(PROTOCOL_VERSION);/*from   ww  w  . j  a v  a2  s .  c  o m*/
    output.writeByte(FRAME_COMPRESSED);

    ByteArrayOutputStream uncompressedBytes = new ByteArrayOutputStream();
    DataOutputStream uncompressedOutput = new DataOutputStream(uncompressedBytes);
    for (Map<String, byte[]> keyValues : keyValuesList) {
        logger.trace("Adding data frame");
        sendDataFrame(uncompressedOutput, keyValues);
    }
    uncompressedOutput.close();
    Deflater compressor = new Deflater();
    byte[] uncompressedData = uncompressedBytes.toByteArray();
    logger.trace("Deflating data: {} bytes", uncompressedData.length);
    if (logger.isTraceEnabled()) {
        HexDump.dump(uncompressedData, 0, System.out, 0);
    }
    compressor.setInput(uncompressedData);
    compressor.finish();

    ByteArrayOutputStream compressedBytes = new ByteArrayOutputStream();
    byte[] buffer = new byte[1024];
    while (!compressor.finished()) {
        int count = compressor.deflate(buffer);
        compressedBytes.write(buffer, 0, count);
    }
    compressedBytes.close();
    byte[] compressedData = compressedBytes.toByteArray();
    logger.trace("Deflated data: {} bytes", compressor.getTotalOut());
    if (logger.isTraceEnabled()) {
        HexDump.dump(compressedData, 0, System.out, 0);
    }

    output.writeInt(compressor.getTotalOut());
    output.write(compressedData);
    output.flush();

    logger.trace("Sending compressed frame: {} frames", keyValuesList.size());
    return 6 + compressor.getTotalOut();
}

From source file:us.ihmc.rtps.visualizer.HexStringMessage.java

@Override
public String toString() {
    try {/*ww w  .  ja v  a 2 s. c  o m*/
        StringBuilderWriter writer = new StringBuilderWriter(data.length << 1 + 2);
        writer.write("Encapsulation: ");
        writer.write(endianness);
        writer.write(System.lineSeparator());
        WriterOutputStream os = new WriterOutputStream(writer);
        HexDump.dump(data, 0, os, 0);
        os.close();
        return writer.toString();
    } catch (ArrayIndexOutOfBoundsException | IllegalArgumentException | IOException e) {
        return e.getMessage();
    }

}