/*
 * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
package java.net;

import java.io.IOException;
import java.io.FileDescriptor;
import sun.misc.SharedSecrets;
import sun.misc.JavaIOFileDescriptorAccess;

/**
 * This class defines the plain SocketImpl that is used on Windows platforms
 * greater or equal to Windows Vista. These platforms have a dual
 * layer TCP/IP stack and can handle both IPv4 and IPV6 through a
 * single file descriptor.
 *
 * @author Chris Hegarty
 */

class DualStackPlainSocketImpl extends AbstractPlainSocketImpl
{
 static JavaIOFileDescriptorAccess fdAccess = SharedSecrets.getJavaIOFileDescriptorAccess();


 // true if this socket is exclusively bound
 private final boolean exclusiveBind;

 // emulates SO_REUSEADDR when exclusiveBind is true
 private boolean isReuseAddress;

 public DualStackPlainSocketImpl(boolean exclBind) {
 exclusiveBind = exclBind;
 }

 public DualStackPlainSocketImpl(FileDescriptor fd, boolean exclBind) {
 this.fd = fd;
 exclusiveBind = exclBind;
 }

 void socketCreate(boolean stream) throws IOException {
 if (fd == null)
 throw new SocketException("Socket closed");

 int newfd = socket0(stream, false /*v6 Only*/);

 fdAccess.set(fd, newfd);
 }

 void socketConnect(InetAddress address, int port, int timeout)
 throws IOException {
 int nativefd = checkAndReturnNativeFD();

 if (address == null)
 throw new NullPointerException("inet address argument is null.");

 int connectResult;
 if (timeout <= 0) {
 connectResult = connect0(nativefd, address, port);
 } else {
 configureBlocking(nativefd, false);
 try {
 connectResult = connect0(nativefd, address, port);
 if (connectResult == WOULDBLOCK) {
 waitForConnect(nativefd, timeout);
 }
 } finally {
 configureBlocking(nativefd, true);
 }
 }
 /*
 * We need to set the local port field. If bind was called
 * previous to the connect (by the client) then localport field
 * will already be set.
 */
 if (localport == 0)
 localport = localPort0(nativefd);
 }

 void socketBind(InetAddress address, int port) throws IOException {
 int nativefd = checkAndReturnNativeFD();

 if (address == null)
 throw new NullPointerException("inet address argument is null.");

 bind0(nativefd, address, port, exclusiveBind);
 if (port == 0) {
 localport = localPort0(nativefd);
 } else {
 localport = port;
 }

 this.address = address;
 }

 void socketListen(int backlog) throws IOException {
 int nativefd = checkAndReturnNativeFD();

 listen0(nativefd, backlog);
 }

 void socketAccept(SocketImpl s) throws IOException {
 int nativefd = checkAndReturnNativeFD();

 if (s == null)
 throw new NullPointerException("socket is null");

 int newfd = -1;
 InetSocketAddress[] isaa = new InetSocketAddress[1];
 if (timeout <= 0) {
 newfd = accept0(nativefd, isaa);
 } else {
 configureBlocking(nativefd, false);
 try {
 waitForNewConnection(nativefd, timeout);
 newfd = accept0(nativefd, isaa);
 if (newfd != -1) {
 configureBlocking(newfd, true);
 }
 } finally {
 configureBlocking(nativefd, true);
 }
 }
 /* Update (SocketImpl)s' fd */
 fdAccess.set(s.fd, newfd);
 /* Update socketImpls remote port, address and localport */
 InetSocketAddress isa = isaa[0];
 s.port = isa.getPort();
 s.address = isa.getAddress();
 s.localport = localport;
 }

 int socketAvailable() throws IOException {
 int nativefd = checkAndReturnNativeFD();
 return available0(nativefd);
 }

 void socketClose0(boolean useDeferredClose/*unused*/) throws IOException {
 if (fd == null)
 throw new SocketException("Socket closed");

 if (!fd.valid())
 return;

 final int nativefd = fdAccess.get(fd);
 fdAccess.set(fd, -1);
 close0(nativefd);
 }

 void socketShutdown(int howto) throws IOException {
 int nativefd = checkAndReturnNativeFD();
 shutdown0(nativefd, howto);
 }

 // Intentional fallthrough after SO_REUSEADDR
 @SuppressWarnings("fallthrough")
 void socketSetOption(int opt, boolean on, Object value)
 throws SocketException {
 int nativefd = checkAndReturnNativeFD();

 if (opt == SO_TIMEOUT) { // timeout implemented through select.
 return;
 }

 int optionValue = 0;

 switch(opt) {
 case SO_REUSEADDR :
 if (exclusiveBind) {
 // SO_REUSEADDR emulated when using exclusive bind
 isReuseAddress = on;
 return;
 }
 // intentional fallthrough
 case TCP_NODELAY :
 case SO_OOBINLINE :
 case SO_KEEPALIVE :
 optionValue = on ? 1 : 0;
 break;
 case SO_SNDBUF :
 case SO_RCVBUF :
 case IP_TOS :
 optionValue = ((Integer)value).intValue();
 break;
 case SO_LINGER :
 if (on) {
 optionValue = ((Integer)value).intValue();
 } else {
 optionValue = -1;
 }
 break;
 default :/* shouldn't get here */
 throw new SocketException("Option not supported");
 }

 setIntOption(nativefd, opt, optionValue);
 }

 int socketGetOption(int opt, Object iaContainerObj) throws SocketException {
 int nativefd = checkAndReturnNativeFD();

 // SO_BINDADDR is not a socket option.
 if (opt == SO_BINDADDR) {
 localAddress(nativefd, (InetAddressContainer)iaContainerObj);
 return 0; // return value doesn't matter.
 }

 // SO_REUSEADDR emulated when using exclusive bind
 if (opt == SO_REUSEADDR && exclusiveBind)
 return isReuseAddress? 1 : -1;

 int value = getIntOption(nativefd, opt);

 switch (opt) {
 case TCP_NODELAY :
 case SO_OOBINLINE :
 case SO_KEEPALIVE :
 case SO_REUSEADDR :
 return (value == 0) ? -1 : 1;
 }
 return value;
 }

 void socketSendUrgentData(int data) throws IOException {
 int nativefd = checkAndReturnNativeFD();
 sendOOB(nativefd, data);
 }

 private int checkAndReturnNativeFD() throws SocketException {
 if (fd == null || !fd.valid())
 throw new SocketException("Socket closed");

 return fdAccess.get(fd);
 }

 static final int WOULDBLOCK = -2; // Nothing available (non-blocking)

 static {
 initIDs();
 }

 /* Native methods */

 static native void initIDs();

 static native int socket0(boolean stream, boolean v6Only) throws IOException;

 static native void bind0(int fd, InetAddress localAddress, int localport,
 boolean exclBind)
 throws IOException;

 static native int connect0(int fd, InetAddress remote, int remotePort)
 throws IOException;

 static native void waitForConnect(int fd, int timeout) throws IOException;

 static native int localPort0(int fd) throws IOException;

 static native void localAddress(int fd, InetAddressContainer in) throws SocketException;

 static native void listen0(int fd, int backlog) throws IOException;

 static native int accept0(int fd, InetSocketAddress[] isaa) throws IOException;

 static native void waitForNewConnection(int fd, int timeout) throws IOException;

 static native int available0(int fd) throws IOException;

 static native void close0(int fd) throws IOException;

 static native void shutdown0(int fd, int howto) throws IOException;

 static native void setIntOption(int fd, int cmd, int optionValue) throws SocketException;

 static native int getIntOption(int fd, int cmd) throws SocketException;

 static native void sendOOB(int fd, int data) throws IOException;

 static native void configureBlocking(int fd, boolean blocking) throws IOException;
}