Traffic.java

/*
 * Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

import java.io.*;
import java.security.*;

class Traffic
{
    private InputStream         in;
    private OutputStream        out;

    //
    // By default, traffic streams are predictable and what comes
    // in is compared with what it's expected to be.
    //
    static private byte fixedSeed [] = { 1, 2, 3, 4};

    private SecureRandom        prng;
    private boolean             compareRandom = true;


    Traffic (InputStream in, OutputStream out)
    {
        this.in = in;
        this.out = out;
        try {
            prng = SecureRandom.getInstance("SHA1PRNG");
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
        prng.setSeed(fixedSeed);
    }

    // optionally provide PRNG for "truly" random data.
    public void setPRNG (SecureRandom prng)
    {
        this.prng = prng;
        compareRandom = false;
    }


    //
    // Basic half-duplex testing, as used for RPC-style systems like
    // HTTP, RMI, CORBA, ONC, etc.
    //
    // parameter 'n' is "0" for some fixed data tests, else is the
    // number of passes of random data to send.
    //

    public void initiate (int n)
    throws IOException
    {
        // System.out.println ("Initiating N = " + n);

        if (n == 0)
            initiateConst ();
        else if (n < 0)
            System.out.println ("** ERROR:  initiate forever ??");
        else
            for ( ; n > 0; n -= 1) {
                initiateRandom ();
            }
    }


    public void respond (int n)
    throws IOException
    {
        if (n == 0)
            respondConst ();
        else if (n < 0)                 // n < 0 == respond forever
            while (true)
                respondRandom ();
        else
            while (n-- > 0)
                respondRandom ();
    }


    //
    // Test passing of fixed size (and content) data.
    //
    // For SSL, one test goal is to ensure that all the basic
    // block cipher padding sizes get banged on.  SSLv3 ciphers
    // are all the same block size, but there are larger sizes
    // coming along.  (Big blocks in hardware can be fast!!)
    //

    private static final int MAX_BLOCKSIZE = 8 * 2;

    private void writeConstData (int n)
    throws IOException
    {
        if (n <= 0)
            return;

        byte buf [] = new byte [n];

        for (int i = 0; i < n; i++)
            buf [i] = (byte) i;

        out.write (buf);

        /*
        System.out.println (Thread.currentThread ().getName ()
            + " wrote const data size = " + n);
        */
    }

    private void readConstData (int n)
    throws IOException
    {
        if (n <= 0)
            return;

        byte buf [] = new byte [n];

        in.read (buf);

        for (int i = 0; i < n; i++)
            if (buf [i] != (byte) i)
                throw new IOException ("const data was incorrect, "
                    + "n = " + n + ", i = " + i);

        /*
        System.out.println (Thread.currentThread ().getName ()
            + " read const data size = " + n);
        */
    }

    private void initiateConst ()
    throws IOException
    {
        for (int i = 1; i <= MAX_BLOCKSIZE; i++) {
            writeConstData (i);
            readConstData (i);
        }

    }

    private void respondConst ()
    throws IOException
    {
        for (int i = 1; i <= MAX_BLOCKSIZE; i++) {
            readConstData (i);
            writeConstData (i);
        }
    }


    //
    // Test passing of random size (and content) data.
    //
    // For SSL, one test goal is to ensure that all the basic
    // record sizes get banged on.  Traffic will normally
    // be bimodal (small packets, and big ones) and we give
    // a half-hearted effort at emulating that -- no real
    // statistics to back up this particular distribution.
    //

    private static final int MAX_RECORDSIZE = 16384 * 2;

    private int nextRecordSize ()
    {
        double  d = prng.nextGaussian ();
        int     n;

        // assume 1/3 traffic is "big", less variance
        if ((prng.nextInt () % 3)  == 0) {
            n = (int) (d * 2048);
            n += 15 * 1024;

        // ... and the rest is smaller, much variance
        } else {
            n = (int) (d * 4096);
            n += 1024;
        }

        if (n < 0)
            return nextRecordSize ();
        else if (n > MAX_RECORDSIZE)
            return MAX_RECORDSIZE;
        else
            return n;
    }


    private void writeRandomData ()
    throws IOException
    {
        int n = nextRecordSize ();
        byte buf [] = new byte [n];

        // System.out.println ("write, size = " + n);

        prng.nextBytes (buf);

        writeInt (n);
        out.write (buf);
    }

    private void readRandomData ()
    throws IOException
    {
        int     n = readInt ();
        byte    actual [] = new byte [n];

        readFully (actual);

        if (compareRandom) {
            byte        expected [];

            if (n != nextRecordSize ())
                throw new IOException ("wrong record size");

            expected = new byte [n];
            prng.nextBytes (expected);

            for (int i = 0; i < n; i++)
                if (actual [i] != expected [i])
                    throw new IOException ("random data was incorrect, "
                        + "n = " + n + ", i = " + i);
        }
    }

    private void initiateRandom ()
    throws IOException
    {
        writeRandomData ();
        readRandomData ();

    }

    private void respondRandom ()
    throws IOException
    {
        readRandomData ();
        writeRandomData ();
    }


    private void readFully (byte buf [])
    throws IOException
    {
        int len = buf.length;
        int offset = 0;
        int value;

        while (len > 0) {
            value = in.read (buf, offset, len);
            if (value == -1)
                throw new EOFException ("read buffer");
            offset += value;
            len -= value;
        }
    }


    private int readInt ()
    throws IOException
    {
        int b0, b1, b2, b3;
        int n;

        b0 = in.read ();
        b1 = in.read ();
        b2 = in.read ();
        b3 = in.read ();

        if (b0 < 0 || b1 < 0 || b2 < 0 || b3 < 0)
            throw new EOFException ();

        /*
        System.out.println ("READ:   b0 = " + b0 + ", b1 = " + b1
            + ", b2 = " + b2 + ", b3 = " + b3);
        */

        n =  (b3 & 0x0ff);
        n |= (b2 & 0x0ff) << 8;
        n |= (b1 & 0x0ff) << 16;
        n |= (b0 & 0x0ff) << 24;
        return n;
    }

    private void writeInt (int n)
    throws IOException
    {
        int b0, b1, b2, b3;

        b3 = n & 0x0ff;
        n >>= 8;
        b2 = n & 0x0ff;
        n >>= 8;
        b1 = n & 0x0ff;
        n >>= 8;
        b0 = n & 0x0ff;

        /*
        System.out.println ("WRITE:  b0 = " + b0 + ", b1 = " + b1
            + ", b2 = " + b2 + ", b3 = " + b3);
        */

        out.write (b0);
        out.write (b1);
        out.write (b2);
        out.write (b3);
    }
}