sun.net.ConnectionResetException Java Examples

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset then return 0 to indicate
     * there are no buffered bytes.
     */
    if (isConnectionReset()) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset then return 0 to indicate
     * there are no buffered bytes.
     */
    if (isConnectionReset()) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

@Override
public int read(ByteBuffer buf) throws IOException {
    Objects.requireNonNull(buf);

    readLock.lock();
    try {
        boolean blocking = isBlocking();
        int n = 0;
        try {
            beginRead(blocking);

            // check if connection has been reset
            if (connectionReset)
                throwConnectionReset();

            // check if input is shutdown
            if (isInputClosed)
                return IOStatus.EOF;

            n = IOUtil.read(fd, buf, -1, nd);
            if (blocking) {
                while (IOStatus.okayToRetry(n) && isOpen()) {
                    park(Net.POLLIN);
                    n = IOUtil.read(fd, buf, -1, nd);
                }
            }
        } catch (ConnectionResetException e) {
            connectionReset = true;
            throwConnectionReset();
        } finally {
            endRead(blocking, n > 0);
            if (n <= 0 && isInputClosed)
                return IOStatus.EOF;
        }
        return IOStatus.normalize(n);
    } finally {
        readLock.unlock();
    }
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
    } catch (ConnectionResetException exc1) {
        setConnectionReset();
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

/**
 * Returns the number of bytes that can be read without blocking.
 */
protected synchronized int available() throws IOException {
    if (isClosedOrPending()) {
        throw new IOException("Stream closed.");
    }

    /*
     * If connection has been reset or shut down for input, then return 0
     * to indicate there are no buffered bytes.
     */
    if (isConnectionReset() || shut_rd) {
        return 0;
    }

    /*
     * If no bytes available and we were previously notified
     * of a connection reset then we move to the reset state.
     *
     * If are notified of a connection reset then check
     * again if there are bytes buffered on the socket.
     */
    int n = 0;
    try {
        n = socketAvailable();
        if (n == 0 && isConnectionResetPending()) {
            setConnectionReset();
        }
    } catch (ConnectionResetException exc1) {
        setConnectionResetPending();
        try {
            n = socketAvailable();
            if (n == 0) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc2) {
        }
    }
    return n;
}
 

@Override
public long read(ByteBuffer[] dsts, int offset, int length)
    throws IOException
{
    Objects.checkFromIndexSize(offset, length, dsts.length);

    readLock.lock();
    try {
        boolean blocking = isBlocking();
        long n = 0;
        try {
            beginRead(blocking);

            // check if connection has been reset
            if (connectionReset)
                throwConnectionReset();

            // check if input is shutdown
            if (isInputClosed)
                return IOStatus.EOF;

            n = IOUtil.read(fd, dsts, offset, length, nd);
            if (blocking) {
                while (IOStatus.okayToRetry(n) && isOpen()) {
                    park(Net.POLLIN);
                    n = IOUtil.read(fd, dsts, offset, length, nd);
                }
            }
        } catch (ConnectionResetException e) {
            connectionReset = true;
            throwConnectionReset();
        } finally {
            endRead(blocking, n > 0);
            if (n <= 0 && isInputClosed)
                return IOStatus.EOF;
        }
        return IOStatus.normalize(n);
    } finally {
        readLock.unlock();
    }
}
 

int read(byte b[], int off, int length, int timeout) throws IOException {
    int n;

    // EOF already encountered
    if (eof) {
        return -1;
    }

    // connection reset
    if (impl.isConnectionReset()) {
        throw new SocketException("Connection reset");
    }

    // bounds check
    if (length <= 0 || off < 0 || length > b.length - off) {
        if (length == 0) {
            return 0;
        }
        throw new ArrayIndexOutOfBoundsException("length == " + length
                + " off == " + off + " buffer length == " + b.length);
    }

    // acquire file descriptor and do the read
    FileDescriptor fd = impl.acquireFD();
    try {
        n = socketRead(fd, b, off, length, timeout);
        if (n > 0) {
            return n;
        }
    } catch (ConnectionResetException rstExc) {
        impl.setConnectionReset();
    } finally {
        impl.releaseFD();
    }

    /*
     * If we get here we are at EOF, the socket has been closed,
     * or the connection has been reset.
     */
    if (impl.isClosedOrPending()) {
        throw new SocketException("Socket closed");
    }
    if (impl.isConnectionReset()) {
        throw new SocketException("Connection reset");
    }
    eof = true;
    return -1;
}