ingrid.yao@Eng 1998-12-15

HP have found an issue with the converter class sun.io.CharToByteDefault
that was included with the 'O' source drop of JDK 1.2. They discovered this
issue when trying out various values for the file.encoding property. The
actual calue that illustrated the problem was the unknown file.encoding,like
roman8.

The following method:

    public int convert(char[] input, int inStart, int inEnd,
                       byte[] output, int outStart, int outEnd)
        throws ConversionBufferFullException
    {
        int j = outStart;
        int i = inStart;
        for (; i < inEnd; i++, j++) {
            if (j >= outEnd)
                throw new ConversionBufferFullException();
            output[j] = (byte) (input[i] & 0x7f);
        }
        charOff = i;
        byteOff = j;
        return j - outStart;
    }

comes from sun.io.CharToByteDefault. If this method is called
outEnd=8192 (the default size) and inEnd > outEnd then the
ConversionBufferFullException() is thrown, *and* the values of charOff
and byteOff are left unchanged. If this is the first time this method
is called then charOff and byteOff have the value 0.

If you now look at the indirect caller of this method (the write method
in the OutputStreamWriter class) that catches this exception, which is
called with off=0, len=8193:

    public void write(char cbuf[], int off, int len)
        throws IOException
    {
        synchronized (lock) {
        ensureOpen();
        if ((off < 0) || (off > cbuf.length) || (len < 0) ||
           ((off + len) > cbuf.length) || ((off + len) < 0)) {
                throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return;
        }
        int ci = off, end = off + len;
        boolean bufferFlushed = false;
        while (ci < end) {
            boolean bufferFull = false;
            try {
                nextByte += ctb.convertAny(cbuf, ci, end,
                                           bb, nextByte, nBytes);
                ci = end;
            } catch (ConversionBufferFullException x) {
                int nci = ctb.nextCharIndex();
                if ((nci == ci) && bufferFlushed) {
                    /* If the buffer has been flushed and it
                       still does not hold even one character */
                    throw new
                        CharConversionException("Output buffer too
small");
                }
                ci = nci;
                bufferFull = true;
                nextByte = ctb.nextByteIndex();
            }
            if ((nextByte >= nBytes) || bufferFull) {
                out.write(bb, 0, nextByte);
                nextByte = 0;
                bufferFlushed = true;
            }
        }
        }
    }

you will notice that nci and nextByte are assigned the value of charOff
and byteOff respectively. Since the convert routine does not change the
values of charOff and ByteOff the value of nci and nextByte is zero. The
first time around the above method calls out.write() with (bb, 0, 0) and
the second time around the "Output buffer too small" exception is
thrown.

The following test case (synthesized from JCK 1.2a) can illustrate the
problem if the value of the file.encoding property is something unknown
to Java (e.g., "roman8"):


import java.io.*;

public class WriteTest0011
{
    private static final int LONG_VALUE = 10000;

    public static void main(String argv[])
    {
        WriteTest0011 test = new WriteTest0011();
        System.exit(test.Test0011());
    }

    public int Test0011()
    {
        int status = 0;

        char[] chars = new char[LONG_VALUE];
        for (int i=0; i < chars.length; ++i) {
            chars[i] = (char)(i%128);
        }
        return BoundaryTestForWriteMethod(chars, 0, chars.length);
    }

    // Method to test for Boundary conditions of write(char[],int,int)
    private int BoundaryTestForWriteMethod(char chars[], int offset, int
len)
    {
        File tempFile = new File("TempFile");
        FileWriter fw = null;

        try {
            fw = new FileWriter(tempFile);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }

        try {
            System.out.println("offset = " + offset + " len = " + len);
            fw.write(chars,offset,len);
            fw.flush();
        } catch(IOException e) { //we never expect IOException
            e.printStackTrace();
            return -1;
        }

        return 0;
    }
}