/*
 * Copyright (c) 1996, 2001, 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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.
 */

package sun.rmi.transport.tcp;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketException;
import java.rmi.*;
import java.rmi.server.RMISocketFactory;
import sun.rmi.runtime.Log;
import sun.rmi.transport.*;
import sun.rmi.transport.proxy.*;

public class TCPConnection implements Connection {

    private Socket socket;
    private Channel channel;
    private InputStream in = null;
    private OutputStream out = null;
    private long expiration = Long.MAX_VALUE;
    private long lastuse = Long.MIN_VALUE;
    private long roundtrip = 5; // round-trip time for ping

    /**
     * Constructor used for creating a connection to accept call
     * (an input connection)
     */
    TCPConnection(TCPChannel ch, Socket s, InputStream in, OutputStream out)
    {
        socket   = s;
        channel  = ch;
        this.in  = in;
        this.out = out;
    }

    /**
     * Constructor used by subclass when underlying input and output streams
     * are already available.
     */
    TCPConnection(TCPChannel ch, InputStream in, OutputStream out)
    {
        this(ch, null, in, out);
    }

    /**
     * Constructor used when socket is available, but not underlying
     * streams.
     */
    TCPConnection(TCPChannel ch, Socket s)
    {
        this(ch, s, null, null);
    }

    /**
     * Gets the output stream for this connection
     */
    public OutputStream getOutputStream() throws IOException
    {
        if (out == null)
            out = new BufferedOutputStream(socket.getOutputStream());
        return out;
    }

    /**
     * Release the output stream for this connection.
     */
    public void releaseOutputStream() throws IOException
    {
        if (out != null)
            out.flush();
    }

    /**
     * Gets the input stream for this connection.
     */
    public InputStream getInputStream() throws IOException
    {
        if (in == null)
            in = new BufferedInputStream(socket.getInputStream());
        return in;
    }


    /**
     * Release the input stream for this connection.
     */
    public void releaseInputStream()
    {
    }

    /**
     * Determine if this connection can be used for multiple operations.
     * If the socket implements RMISocketInfo, then we can query it about
     * this; otherwise, assume that it does provide a full-duplex
     * persistent connection like java.net.Socket.
     */
    public boolean isReusable()
    {
        if ((socket != null) && (socket instanceof RMISocketInfo))
            return ((RMISocketInfo) socket).isReusable();
        else
            return true;
    }

    /**
     * Set the expiration time of this connection.
     * @param time The time at which the time out expires.
     */
    void setExpiration(long time)
    {
        expiration = time;
    }

    /**
     * Set the timestamp at which this connection was last used successfully.
     * The connection will be pinged for liveness if reused long after
     * this time.
     * @param time The time at which the connection was last active.
     */
    void setLastUseTime(long time)
    {
        lastuse = time;
    }

    /**
     * Returns true if the timeout has expired on this connection;
     * otherwise returns false.
     * @param time The current time.
     */
    boolean expired(long time)
    {
        return expiration <= time;
    }

    /**
     * Probes the connection to see if it still alive and connected to
     * a responsive server.  If the connection has been idle for too
     * long, the server is pinged.  ``Too long'' means ``longer than the
     * last ping round-trip time''.
     * <P>
     * This method may misdiagnose a dead connection as live, but it
     * will never misdiagnose a live connection as dead.
     * @return true if the connection and server are recently alive
     */
    public boolean isDead()
    {
        InputStream i;
        OutputStream o;

        // skip ping if recently used within 1 RTT
        long start = System.currentTimeMillis();
        if ((roundtrip > 0) && (start < lastuse + roundtrip))
            return (false);     // still alive and warm

        // Get the streams
        try {
            i = getInputStream();
            o = getOutputStream();
        } catch (IOException e) {
            return (true);      // can't even get a stream, must be very dead
        }

        // Write the ping byte and read the reply byte
        int response = 0;
        try {
            o.write(TransportConstants.Ping);
            o.flush();
            response = i.read();
        } catch (IOException ex) {
            TCPTransport.tcpLog.log(Log.VERBOSE, "exception: ", ex);
            TCPTransport.tcpLog.log(Log.BRIEF, "server ping failed");

            return (true);      // server failed the ping test
        }

        if (response == TransportConstants.PingAck) {
            // save most recent RTT for future use
            roundtrip = (System.currentTimeMillis() - start) * 2;
            // clock-correction may make roundtrip < 0; doesn't matter
            return (false);     // it's alive and 5-by-5
        }

        if (TCPTransport.tcpLog.isLoggable(Log.BRIEF)) {
            TCPTransport.tcpLog.log(Log.BRIEF,
                (response == -1 ? "server has been deactivated" :
                "server protocol error: ping response = " + response));
        }
        return (true);
    }

    /**
     * Close the connection.  */
    public void close() throws IOException
    {
        TCPTransport.tcpLog.log(Log.BRIEF, "close connection");

        if (socket != null)
            socket.close();
        else {
            in.close();
            out.close();
        }
    }

    /**
     * Returns the channel for this connection.
     */
    public Channel getChannel()
    {
        return channel;
    }
}