import java.net.SocketOptions; //导入依赖的package包/类
public Object getOption(int optID) throws IOException
{
    if (fd == null) {
        throw new IOException("socket not created");
    }

    if (optID == SocketOptions.SO_TIMEOUT) {
        return 0;
    }

    int value = getOption_native(fd, optID);
    switch (optID)
    {
        case SocketOptions.SO_RCVBUF:
        case SocketOptions.SO_SNDBUF:
            return value;
        case SocketOptions.SO_REUSEADDR:
        default:
            return value;
    }
}
 

import java.net.SocketOptions; //导入依赖的package包/类
@Override
protected void bind(InetAddress host, int port) throws IOException {

       if(port == 0) {
           port = VirtualNetwork.getInstance().getNewLocalEphemeralPort();
       }

	//TODO: need to check special cases like multicast
	boolean opened = VirtualNetwork.getInstance().openTcpServer(host.getHostAddress(), port);
	if(!opened) {
		throw new IOException("Failed to open TCP port");
	}
	super.localport = port;
	setOption(SocketOptions.SO_BINDADDR, host);
       isBound = true;
}
 

import java.net.SocketOptions; //导入依赖的package包/类
private boolean isLingerSocket(FileDescriptor fd) throws SocketException {
    try {
        Object lingerValue = mNetwork.getSocketOption(fd, SocketOptions.SO_LINGER);
        if (lingerValue instanceof Boolean) {
            return (Boolean) lingerValue;
        } else if (lingerValue instanceof Integer) {
            return ((Integer) lingerValue) != 0;
        }
        throw new AssertionError(lingerValue.getClass().getName());
    } catch (Exception ignored) {
        // We're called via Socket.close (which doesn't ask for us to be called), so we
        // must not throw here, because Socket.close must not throw if asked to close an
        // already-closed socket.
        return false;
    }
}
 

import java.net.SocketOptions; //导入依赖的package包/类
@Override
public Object getOption(int optID) throws SocketException {
    if (optID == SocketOptions.SO_TIMEOUT) {
        return Integer.valueOf(receiveTimeout);
    } else if (optID == SocketOptions.IP_TOS) {
        return Integer.valueOf(trafficClass);
    } else {
        // Call the native first so there will be
        // an exception if the socket if closed.
        Object result = netImpl.getSocketOption(fd, optID);
        if (optID == SocketOptions.IP_MULTICAST_IF
                && (netImpl.getSocketFlags() & MULTICAST_IF) != 0) {
            try {
                return InetAddress.getByAddress(ipaddress);
            } catch (UnknownHostException e) {
                return null;
            }
        }
        return result;
    }
}
 

import java.net.SocketOptions; //导入依赖的package包/类
public Object getOption(int optID) throws SocketException {
    if (optID == SocketOptions.SO_TIMEOUT) {
        return Integer.valueOf(receiveTimeout);
    } else if (optID == SocketOptions.IP_TOS) {
        return Integer.valueOf(trafficClass);
    } else {
        // Call the native first so there will be
        // an exception if the socket if closed.
        Object result = netImpl.getSocketOption(fd, optID);
        if (optID == SocketOptions.IP_MULTICAST_IF
                && (netImpl.getSocketFlags() & MULTICAST_IF) != 0) {
            try {
                return InetAddress.getByAddress(ipaddress);
            } catch (UnknownHostException e) {
                return null;
            }
        }
        return result;
    }
}
 

import java.net.SocketOptions; //导入依赖的package包/类
@Override
public Object getOption(int optID) throws SocketException {
    if (optID == SocketOptions.SO_TIMEOUT) {
        return Integer.valueOf(receiveTimeout);
    } else if (optID == SocketOptions.IP_TOS) {
        return Integer.valueOf(trafficClass);
    } else {
        // Call the native first so there will be
        // an exception if the socket if closed.
        Object result = netImpl.getSocketOption(fd, optID);
        if (optID == SocketOptions.TCP_NODELAY
                && (netImpl.getSocketFlags() & TCP_NODELAY) != 0) {
            return Boolean.valueOf(tcpNoDelay);
        }
        return result;
    }
}
 

import java.net.SocketOptions; //导入依赖的package包/类
public Object getOption(int key) throws SocketException {
    if (key==SocketOptions.SO_TIMEOUT) {
        // get timeout
        return inputStreamTimeout;
    }
    if (key==SocketOptions.TCP_NODELAY) {
        return tcpNodelay;
    }
    if (key==SocketOptions.SO_LINGER) {
        // get timeout
        return soLinger;
    }
    
    // unsupported option
    String msg = "no implementation for getOption("+key+"). List of all options in java.net.SocketOptions.";
    if (log.isLoggable(Level.FINER)) {
        log.log(Level.FINER, msg, new Throwable("method not completely implemented"));
    } else {
        log.info(msg+" - Log with level=FINER to get call hierarchy.");
    }
    return null;
}
 

import java.net.SocketOptions; //导入依赖的package包/类
/**
 * Non-synchronized on purpose (TODO refactor away the need to do this)
 */
@SuppressWarnings("sync-override")
@Override
public void setTrafficClass(int tc) throws SocketException {
    if (tc < 0 || tc > 255) {
        throw new IllegalArgumentException("tc is not in range 0 -- 255");
    }
    if (isClosed()) {
        throw new SocketException("Socket is closed");
    }
    impl.setOption(SocketOptions.IP_TOS, tc);

}
 

import java.net.SocketOptions; //导入依赖的package包/类
public void setOption(int optionId, Object optionValue)
  throws SocketException
{
  int value;
  if (optionValue instanceof Integer)
    value = ((Integer) optionValue).intValue();
  else if (optionValue instanceof Boolean)
    // Switching off the linger behavior is done by setting
    // the value to -1. This is how the Java API interprets
    // it.
    value = ((Boolean) optionValue).booleanValue()
            ? 1
            : (optionId == SocketOptions.SO_LINGER)
            ? -1
            : 0;
  else
    throw new IllegalArgumentException("option value type "
                                       + optionValue.getClass().getName());

  try
    {
      setOption(nfd.getNativeFD(), optionId, value);
    }
  catch (IOException ioe)
    {
      SocketException se = new SocketException();
      se.initCause(ioe);
      throw se;
    }
}
 

import java.net.SocketOptions; //导入依赖的package包/类
/**
 * Get a socket option. This implementation is only required to support
 * socket options that are boolean values, which include:
 *
 *  SocketOptions.IP_MULTICAST_LOOP
 *  SocketOptions.SO_BROADCAST
 *  SocketOptions.SO_KEEPALIVE
 *  SocketOptions.SO_OOBINLINE
 *  SocketOptions.SO_REUSEADDR
 *  SocketOptions.TCP_NODELAY
 *
 * and socket options that are integer values, which include:
 *
 *  SocketOptions.IP_TOS
 *  SocketOptions.SO_LINGER
 *  SocketOptions.SO_RCVBUF
 *  SocketOptions.SO_SNDBUF
 *  SocketOptions.SO_TIMEOUT
 *
 * @param optionId The option ID to fetch.
 * @return A {@link Boolean} or {@link Integer} containing the socket
 *  option.
 * @throws SocketException
 */
public Object getOption(int optionId) throws SocketException
{
  int value;
  try
    {
      value = getOption(nfd.getNativeFD(), optionId);
    }
  catch (IOException ioe)
    {
      SocketException se = new SocketException();
      se.initCause(ioe);
      throw se;
    }

  switch (optionId)
    {
      case SocketOptions.IP_MULTICAST_LOOP:
      case SocketOptions.SO_BROADCAST:
      case SocketOptions.SO_KEEPALIVE:
      case SocketOptions.SO_OOBINLINE:
      case SocketOptions.SO_REUSEADDR:
      case SocketOptions.TCP_NODELAY:
        return Boolean.valueOf(value != 0);

      case SocketOptions.IP_TOS:
      case SocketOptions.SO_LINGER:
      case SocketOptions.SO_RCVBUF:
      case SocketOptions.SO_SNDBUF:
      case SocketOptions.SO_TIMEOUT:
        return new Integer(value);

      default:
        throw new SocketException("getting option " + optionId +
                                  " not supported here");
    }
}
 

import java.net.SocketOptions; //导入依赖的package包/类
public void setOption(int optionId, Object optionValue)
  throws SocketException
{
  int value;
  if (optionValue instanceof Integer)
    value = ((Integer) optionValue).intValue();
  else if (optionValue instanceof Boolean)
    // Switching off the linger behavior is done by setting
    // the value to -1. This is how the Java API interprets
    // it.
    value = ((Boolean) optionValue).booleanValue()
            ? 1
            : (optionId == SocketOptions.SO_LINGER)
            ? -1
            : 0;
  else
    throw new IllegalArgumentException("option value type "
                                       + optionValue.getClass().getName());
  
  try
    {
      setOption(nfd.getNativeFD(), optionId, value);
    }
  catch (IOException ioe)
    {
      SocketException se = new SocketException();
      se.initCause(ioe);
      throw se;
    }
}
 

import java.net.SocketOptions; //导入依赖的package包/类
/**
 * Get a socket option. This implementation is only required to support
 * socket options that are boolean values, which include:
 * 
 *  SocketOptions.IP_MULTICAST_LOOP
 *  SocketOptions.SO_BROADCAST
 *  SocketOptions.SO_KEEPALIVE
 *  SocketOptions.SO_OOBINLINE
 *  SocketOptions.SO_REUSEADDR
 *  SocketOptions.TCP_NODELAY
 * 
 * and socket options that are integer values, which include:
 * 
 *  SocketOptions.IP_TOS
 *  SocketOptions.SO_LINGER
 *  SocketOptions.SO_RCVBUF
 *  SocketOptions.SO_SNDBUF
 *  SocketOptions.SO_TIMEOUT
 *
 * @param optionId The option ID to fetch.
 * @return A {@link Boolean} or {@link Integer} containing the socket
 *  option.
 * @throws SocketException
 */
public Object getOption(int optionId) throws SocketException
{
  int value;
  try
    {
      value = getOption(nfd.getNativeFD(), optionId);
    }
  catch (IOException ioe)
    {
      SocketException se = new SocketException();
      se.initCause(ioe);
      throw se;
    }
  
  switch (optionId)
    {
      case SocketOptions.IP_MULTICAST_LOOP:
      case SocketOptions.SO_BROADCAST:
      case SocketOptions.SO_KEEPALIVE:
      case SocketOptions.SO_OOBINLINE:
      case SocketOptions.SO_REUSEADDR:
      case SocketOptions.TCP_NODELAY:
        return Boolean.valueOf(value != 0);
        
      case SocketOptions.IP_TOS:
      case SocketOptions.SO_LINGER:
      case SocketOptions.SO_RCVBUF:
      case SocketOptions.SO_SNDBUF:
      case SocketOptions.SO_TIMEOUT:
        return new Integer(value);
        
      default:
        throw new SocketException("getting option " + optionId +
                                  " not supported here");
    }
}
 

import java.net.SocketOptions; //导入依赖的package包/类
@Override
protected void create(boolean isStreaming) throws IOException {
    super.create(isStreaming);
    if (isStreaming) {
        setOption(SocketOptions.SO_REUSEADDR, Boolean.TRUE);
    }
}
 

import java.net.SocketOptions; //导入依赖的package包/类
@Override
public Object getOption(final int key) throws SocketException
{
	if (key == SocketOptions.SO_TIMEOUT)
	{
		// get timeout
		return inputStreamTimeout;
	}
	if (key == SocketOptions.TCP_NODELAY)
	{
		return tcpNodelay;
	}
	if (key == SocketOptions.SO_LINGER)
	{
		// get timeout
		return soLinger;
	}

	// unsupported option
	final String msg = "no implementation for getOption(" + key
			+ "). List of all options in java.net.SocketOptions.";
	if (logger.isDebugEnabled())
	{
		logger.debug(msg, new Throwable("method not completely implemented"));
	}
	else
	{
		logger.info(msg + " - Log with level=debug to get call hierarchy.");
	}
	return null;
}
 

import java.net.SocketOptions; //导入依赖的package包/类
@Override
public void setSoLinger(boolean on, int linger) throws SocketException {
	if (isClosed())
		throw new SocketException("Socket is closed");
	if (!on) {
		getImpl().setOption(SocketOptions.SO_LINGER, new Boolean(on));
	} else {
		if (linger < 0) {
			throw new IllegalArgumentException("invalid value for SO_LINGER");
		}
		if (linger > 65535)
			linger = 65535;
		getImpl().setOption(SocketOptions.SO_LINGER, new Integer(linger));
	}
}
 

import java.net.SocketOptions; //导入依赖的package包/类
@Override
public int getSoLinger() throws SocketException {
	if (isClosed())
		throw new SocketException("Socket is closed");
	Object o = getImpl().getOption(SocketOptions.SO_LINGER);
	if (o instanceof Integer) {
		return ((Integer) o).intValue();
	} else {
		return -1;
	}
}
 

import java.net.SocketOptions; //导入依赖的package包/类
@Override
public synchronized void setSoTimeout(int timeout) throws SocketException {
	if (isClosed())
		throw new SocketException("Socket is closed");
	if (timeout < 0)
		throw new IllegalArgumentException("timeout can't be negative");

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

import java.net.SocketOptions; //导入依赖的package包/类
@Override
public synchronized int getSoTimeout() throws SocketException {
	if (isClosed())
		throw new SocketException("Socket is closed");
	Object o = getImpl().getOption(SocketOptions.SO_TIMEOUT);
	if (o instanceof Integer) {
		return ((Integer) o).intValue();
	} else {
		return 0;
	}
}
 

import java.net.SocketOptions; //导入依赖的package包/类
@Override
public synchronized void setSendBufferSize(int size) throws SocketException{
	if (!(size > 0)) {
		throw new IllegalArgumentException("negative send size");
	}
	if (isClosed())
		throw new SocketException("Socket is closed");
	getImpl().setOption(SocketOptions.SO_SNDBUF, new Integer(size));
}
 

import java.net.SocketOptions; //导入依赖的package包/类
@Override
public synchronized int getSendBufferSize() throws SocketException {
	if (isClosed())
		throw new SocketException("Socket is closed");
	int result = 0;
	Object o = getImpl().getOption(SocketOptions.SO_SNDBUF);
	if (o instanceof Integer) {
		result = ((Integer)o).intValue();
	}
	return result;
}