serversocket.java

this gcc-g++-3.3.1.tar.gz is a source file of gcc, you can learn more about gcc through this codes f

   * instance representing that connection.  This method will block until a 
   * connection is available.
   *
   * @exception IOException If an error occurs
   * @exception SecurityException If a security manager exists and its
   * checkListen method doesn't allow the operation
   * @exception IllegalBlockingModeException If this socket has an associated
   * channel, and the channel is in non-blocking mode
   * @exception SocketTimeoutException If a timeout was previously set with
   * setSoTimeout and the timeout has been reached
   */
  public Socket accept () throws IOException
  {
    if (impl == null)
      throw new IOException ("Cannot initialize Socket implementation");

    SecurityManager sm = System.getSecurityManager ();
    if (sm != null)
      sm.checkListen (impl.getLocalPort ());

    Socket s = new Socket();
    implAccept (s);

    return s;
  }

  /**
   * This protected method is used to help subclasses override 
   * <code>ServerSocket.accept()</code>.  The passed in socket will be
   * connected when this method returns.
   *
   * @param socket The socket that is used for the accepted connection
   *
   * @exception IOException If an error occurs
   * @exception IllegalBlockingModeException If this socket has an associated
   * channel, and the channel is in non-blocking mode
   *
   * @since 1.1
   */
  protected final void implAccept (Socket s)
    throws IOException
  {
    if (ch != null && !ch.isBlocking())
      throw new IllegalBlockingModeException();
	    
    impl.accept(s.impl);
  }

  /**
   * Closes this socket and stops listening for connections
   *
   * @exception IOException If an error occurs
   */
  public void close () throws IOException
  {
    if (impl != null)
      impl.close ();

    if (ch != null)
      ch.close ();
    
    closed = true;
  }

  /**
   * Returns the unique ServerSocketChannel object
   * associated with this socket, if any.
   *
   * The socket only has a ServerSocketChannel if its created
   * by ServerSocketChannel.open.
   * 
   * @since 1.4
   */
  public ServerSocketChannel getChannel()
  {
    return ch;
  }

  /**
   * Returns true then the socket is bound, otherwise false
   * 
   * @since 1.4
   */
  public boolean isBound()
  {
    try
      {
        Object bindaddr = impl.getOption (SocketOptions.SO_BINDADDR);
      }
    catch (SocketException e)
      {
        return false;
      }
    
    return true;
  }

  /**
   * Returns true if the socket is closed, otherwise false
   * 
   * @since 1.4
   */
  public boolean isClosed()
  {
    return closed;
  }

  /**
   * Sets the value of SO_TIMEOUT.  A value of 0 implies that SO_TIMEOUT is
   * disabled (ie, operations never time out).  This is the number of 
   * milliseconds a socket operation can block before an
   * InterruptedIOException is thrown.
   *
   * @param timeout The new SO_TIMEOUT value
   *
   * @exception SocketException If an error occurs
   *
   * @since 1.1
   */
  public void setSoTimeout (int timeout) throws SocketException
  {
    if (timeout < 0)
      throw new IllegalArgumentException("SO_TIMEOUT value must be >= 0");

    impl.setOption(SocketOptions.SO_TIMEOUT, new Integer(timeout));
  }

  /**
   * Retrieves the current value of the SO_TIMEOUT setting.  A value of 0
   * implies that SO_TIMEOUT is disabled (ie, operations never time out).
   * This is the number of milliseconds a socket operation can block before
   * an InterruptedIOException is thrown.
   *
   * @return The value of SO_TIMEOUT
   *
   * @exception IOException If an error occurs
   *
   * @since 1.1
   */
  public int getSoTimeout () throws IOException
  {
    Object timeout = impl.getOption(SocketOptions.SO_TIMEOUT);

    if (!(timeout instanceof Integer))
      throw new IOException("Internal Error");

    return ((Integer)timeout).intValue();
  }

  /**
   * Enables/Disables the SO_REUSEADDR option
   * 
   * @exception SocketException If an error occurs
   * 
   * @since 1.4
   */
  public void setReuseAddress (boolean on)
    throws SocketException
  {
    if (impl == null)
      throw new SocketException ("Cannot initialize Socket implementation");

    impl.setOption (SocketOptions.SO_REUSEADDR, new Boolean (on));
  }

  /**
   * Checks if the SO_REUSEADDR option is enabled
   * 
   * @exception SocketException If an error occurs
   * 
   * @since 1.4
   */
  public boolean getReuseAddress()
    throws SocketException
  {
    if (impl == null)
      throw new SocketException ("Cannot initialize Socket implementation");

    Object reuseaddr = impl.getOption (SocketOptions.SO_REUSEADDR);

    if (!(reuseaddr instanceof Boolean))
      throw new SocketException ("Internal Error");
    
    return ((Boolean) reuseaddr).booleanValue ();
  }

  /**
   * This method sets the value for the system level socket option
   * SO_RCVBUF to the specified value.  Note that valid values for this
   * option are specific to a given operating system.
   * 
   * @param size The new receive buffer size.
   * 
   * @exception SocketException If an error occurs or Socket is not connected
   * @exception IllegalArgumentException If size is 0 or negative
   *
   * @since 1.4
   */
  public void setReceiveBufferSize (int size)
    throws SocketException
  {
    if (impl == null)
      throw new SocketException ("Not connected");

    if (size <= 0)
      throw new IllegalArgumentException ("SO_RCVBUF value must be > 0");

    impl.setOption (SocketOptions.SO_RCVBUF, new Integer (size));
  }

  /**
   * This method returns the value of the system level socket option
   * SO_RCVBUF, which is used by the operating system to tune buffer
   * sizes for data transfers.
   * 
   * @return The receive buffer size.
   *             
   * @exception SocketException If an error occurs or Socket is not connected
   * 
   * @since 1.4
   */
  public int getReceiveBufferSize ()
    throws SocketException
  {
    if (impl == null)
      throw new SocketException ("Not connected");

    Object buf = impl.getOption (SocketOptions.SO_RCVBUF);

    if (!(buf instanceof Integer))
      throw new SocketException ("Internal Error: Unexpected type");
    
    return ((Integer) buf).intValue ();
  }

  /**
   * Returns the value of this socket as a <code>String</code>. 
   *
   * @return This socket represented as a <code>String</code>.
   */
  public String toString ()
  {
    return "ServerSocket" + impl.toString();
  }

  // Class methods

  /**
   * Sets the <code>SocketImplFactory</code> for all 
   * <code>ServerSocket</code>'s.  This may only be done
   * once per virtual machine.  Subsequent attempts will generate an
   * exception.  Note that a <code>SecurityManager</code> check is made prior
   * to setting the factory.  If insufficient privileges exist to set the
   * factory, an exception will be thrown
   *
   * @exception SecurityException If this operation is not allowed by the
   * <code>SecurityManager</code>.
   * @exception SocketException If the factory object is already defined
   * @exception IOException If any other error occurs
   */
  public static synchronized void setSocketFactory (SocketImplFactory fac)
    throws IOException
  {
    factory = fac;
  }
}