nonblockingsocket.java

实现非阻塞方式IO(NBIO)的java类

/* 
 * Copyright (c) 2000 by Matt Welsh and The Regents of the University of 
 * California. All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose, without fee, and without written agreement is
 * hereby granted, provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 * 
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
 * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 *
 * Author: Matt Welsh <[e-mail]>
 * 
 */


package ninja2.core.io_core.nbio;

import java.io.*;
import java.net.*;

/**
 * A NonblockingSocket is a socket which exports nonblocking input/output
 * streams. It is otherwise idential to a standard socket.
 *
 * Socket connection can be either blocking or nonblocking. Use of the
 * standard constructors causes the current thread to block until 
 * the connection is established. Otherwise, there are 3 ways to check
 * if the connection has been established: 
 * (1) Call <code>finishConnection</code>,
 * (2) Call <code>connectDone</code>, or 
 * (3) Create a <code>SelectSet</code> and select on the event 
 * <code>Selectable.CONNECT_READY</code>, then call <code>connectDone</code>.
 *
 * @see SelectSet
 */
public class NonblockingSocket extends Socket implements Selectable {

  NonblockingSocketImpl impl;
  boolean is_connected;

  static {
    try {
      System.loadLibrary("NBIO");
    } catch (Exception e) {
      System.err.println("Cannot load NBIO shared library");
    }
  }

  /* Used only by NonblockingServerSocket to create an instance for accept */
  NonblockingSocket() throws IOException {
    impl = new NonblockingSocketImpl();
  }

  /**
   * Create a NonblockingSocket connection to the given host and port number.
   * This will block until the connection is established.
   */
  public NonblockingSocket(String host, int port) throws UnknownHostException, IOException {
    this(InetAddress.getByName(host), port, true);
  }

  /** 
   * Create a NonblockingSocket connection to the given host and port number.
   * If 'block' is true, block until the connection is done.
   */
  public NonblockingSocket(String host, int port, boolean block) throws UnknownHostException, IOException {
    this(InetAddress.getByName(host), port, block);
  }

  /** 
   * Create a NonblockingSocket connection to the given host and port number.
   * This will block until the connection is established.
   */
  public NonblockingSocket(InetAddress address, int port) throws UnknownHostException, IOException {
    this(address, port, true);
  }

  /**
   * Create a NonblockingSocket connection to the given host and port number.
   * If 'block' is true, block until the connection is done.
   */
  public NonblockingSocket(InetAddress address, int port, boolean block) throws IOException {
    impl = new NonblockingSocketImpl();

    if (port < 0 || port > 0xFFFF) { 
      throw new IllegalArgumentException("port out range:"+port); 
    }

    try {
      is_connected = false;
      impl.create(true);
      // 'null' bind address means INADDR_ANY
      impl.bind(null, 0);
      impl.connect(address, port);
      if (block) finishConnect(-1);
    } catch (IOException e) {
      impl.close();
      throw e;
    }
  }

  /** 
   * Block until the connection on this socket has been established.
   * 'timeout' specifies the maximum number of milliseconds to block.
   * A timeout of zero indicates no blocking (in which case this call
   * is equivalent to <code>connectDone</code>). A timeout of -1
   * causes this call to block indefinitely until the connection is 
   * established.
   * 
   * @return true is the connection was established, false if still pending. 
   */ 
  public boolean finishConnect(int timeout) throws SocketException {
    if (timeout != 0) {
      SelectSet selset = new SelectSet();
      SelectItem selitem = new SelectItem(this, Selectable.CONNECT_READY);
      selset.add(selitem);
      int r = selset.select(timeout);
      if (r == 0) {
        return connectDone();
      } else if (!connectDone()) {
        // This should never happen -- connectDone() will throw an exception
        // if there was an error
        throw new SocketException("Socket connection not completed after select! This is a bug - please e-mail [e-mail]");
      }
      return true;
    } else {
      return connectDone();
    }
  }

  /** 
   * Indicate whether the connection on this socket has been established.
   * Throws an exception if an error occurred trying to connect.
   */
  public boolean connectDone() throws SocketException {
    if (is_connected) return true;

    if (impl.connectDone()) {
      is_connected = true;
      return true;
    } else {
      return false;
    }
  }

  /**
   * Return the remote address to which this socket is bound.
   */
  public InetAddress getInetAddress() {
    return impl.getInetAddress();
  }

  /**
   * Return the local address to which this socket is bound.
   */
  public InetAddress getLocalAddress() {
    try {
      return InetAddress.getLocalHost();
    } catch (Exception e) {
      return null; // XXX MDW - Not quite right
    }
  }

  /**
   * Return the remote port to which this socket is bound.
   */
  public int getPort() {
    return impl.getPort();
  }

  /**
   * Return the local port to which this socket is bound.
   */
  public int getLocalPort() {
    return impl.getLocalPort();
  }

  /**
   * Return an InputStream from which data on this socket can be read.
   * The returned InputStream is actually a NonblockingInputStream
   * and provides nonblocking semantics.
   */
  public InputStream getInputStream() throws IOException {
    return impl.getInputStream();
  }

  /**
   * Return an OutputStream to which data on this socket can be written.
   * The returned OutputStream is actually a NonblockingOutputStream
   * and provides nonblocking semantics.
   */
  public OutputStream getOutputStream() throws IOException {
    return impl.getOutputStream();
  }

  /**
   * Currently unimplemented.
   */
  public void setTcpNoDelay(boolean on) throws SocketException {
    // XXX MDW Do nothing
  }

  /**
   * Currently unimplemented.
   */
  public boolean getTcpNoDelay() throws SocketException {
    // XXX MDW Do nothing
    return false;
  }

  /**
   * Currently unimplemented.
   */
  public void setSoLinger(boolean on, int val) throws SocketException {
    // XXX MDW Do nothing
  }

  /**
   * Currently unimplemented.
   */
  public int getSoLinger() throws SocketException {
    // XXX MDW Do nothing
    return -1;
  }
  
  /**
   * Currently unimplemented.
   */
  public synchronized void setSoTimeout(int timeout) throws SocketException {
    // XXX MDW Do nothing
  }

  /**
   * Currently unimplemented.
   */
  public synchronized int getSoTimeout() throws SocketException {
    // XXX MDW Do nothing
    return 0;
  }

  /**
   * Closes the socket.
   */
  public synchronized void close() throws IOException {
    impl.close();
  }

  public String toString() {
    return "NonblockingSocket[addr="+impl.getInetAddress().getHostAddress()+",port="+impl.getPort()+",localport="+impl.getLocalPort()+"]";
  }

}