java类java.net.SocketOptions的实例源码

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;
    }
}

@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;
}

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;
    }
}

@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;
    }
}

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;
    }
}

@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;
    }
}

@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;
    }
}

@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;
    }
}

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;
    }
}

@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;
    }
}

@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;
    }
}

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;
}

/**
 * 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);

}

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;
    }
}

/**
 * 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");
    }
}

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;
    }
}

/**
 * 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");
    }
}

@Override
protected void create(boolean isStreaming) throws IOException {
    super.create(isStreaming);
    if (isStreaming) {
        setOption(SocketOptions.SO_REUSEADDR, Boolean.TRUE);
    }
}

@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;
}

@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));
    }
}

@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;
    }
}

@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));
}

@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;
    }
}

@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));
}

@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;
}

@Override
public synchronized void setReceiveBufferSize(int size) throws SocketException{
    if (size <= 0) {
        throw new IllegalArgumentException("invalid receive size");
    }
    if (isClosed())
        throw new SocketException("Socket is closed");
    getImpl().setOption(SocketOptions.SO_RCVBUF, new Integer(size));
}

@Override
public synchronized int getReceiveBufferSize() throws SocketException{
    if (isClosed())
        throw new SocketException("Socket is closed");
    int result = 0;
    Object o = getImpl().getOption(SocketOptions.SO_RCVBUF);
    if (o instanceof Integer) {
        result = ((Integer)o).intValue();
    }
    return result;
}

@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");
    getImpl().setOption(SocketOptions.IP_TOS, new Integer(tc));
}

private void initOptions() {
    // see AbstractPlainSocketImpl
    options.put(SocketOptions.SO_TIMEOUT, 0);
    options.put(SocketOptions.SO_RCVBUF, 131072);
    options.put(SocketOptions.SO_SNDBUF, 131072);
    options.put(SocketOptions.SO_LINGER, -1);
    options.put(SocketOptions.SO_KEEPALIVE, false);
    options.put(SocketOptions.SO_OOBINLINE, false);
    options.put(SocketOptions.SO_REUSEADDR, false);
    options.put(SocketOptions.TCP_NODELAY, false);
       options.put(SocketOptions.IP_TOS, 0);
}

@Override
protected void accept(SocketImpl s) throws IOException {

    if(!(s instanceof EvoSuiteSocket)) {
        throw new IOException("Can only handle mocked sockets");
    }

    EvoSuiteSocket mock = (EvoSuiteSocket) s;

    /*
     * If the test case has set up an incoming connection, then
     * simulate an immediate connection.
     * If not, there is no point in blocking the SUT for
     * a connection that will never arrive: just throw an exception
     */

    InetAddress localHost = (InetAddress) options.get(SocketOptions.SO_BINDADDR); 
    NativeTcp tcp = VirtualNetwork.getInstance().pullTcpConnection(localHost.getHostAddress(),localport);

    if(tcp == null) {
        throw new IOException("Simulated exception on waiting server");
    } else {
        mock.openedConnection = tcp;
        mock.setOption(SocketOptions.SO_BINDADDR, localHost);       
        mock.setLocalPort(localport);
        mock.setRemoteAddress(InetAddress.getByName(tcp.getRemoteEndPoint().getHost()));
        mock.setRemotePort(tcp.getRemoteEndPoint().getPort());
    }
}