Java example source code file (Traffic.java)

This example Java source code file (Traffic.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

eofexception, inputstream, ioexception, max_blocksize, max_recordsize, nosuchalgorithmexception, outputstream, runtimeexception, securerandom, security, sha1prng, traffic

The Traffic.java Java example source code

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