/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package jdk.internal.net.rdma;

import java.io.FileDescriptor;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Inet4Address;

import java.net.Inet6Address;

import java.net.InetAddress;

import java.net.InetSocketAddress;

import java.net.ProtocolFamily;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.SocketAddress;

import java.net.SocketException;

import java.net.SocketImpl;

import java.net.SocketOption;

import java.net.SocketOptions;

import java.net.StandardSocketOptions;

import java.net.UnknownHostException;

import java.util.Objects;

import java.util.Set;

import sun.nio.ch.Net;

import static java.net.StandardProtocolFamily.INET;

import static java.net.StandardProtocolFamily.INET6;

public abstract class RdmaSocketImpl extends SocketImpl

{

    private ProtocolFamily family;

    Socket socket = null;

    ServerSocket serverSocket = null;

    int timeout;   // timeout in millisec

    int trafficClass;

    InputStream socketInputStream;

    OutputStream socketOutputStream;

    private boolean shut_rd = false;

    private boolean shut_wr = false;

    /* number of threads using the FileDescriptor */

    protected int fdUseCount = 0;

    /* lock when increment/decrementing fdUseCount */

    protected final Object fdLock = new Object();

    /* indicates a close is pending on the file descriptor */

    protected boolean closePending = false;

    /* indicates connection reset state */

    private int CONNECTION_NOT_RESET = 0;

    private int CONNECTION_RESET_PENDING = 1;

    private int CONNECTION_RESET = 2;

    private int resetState;

    private final Object resetLock = new Object();

    protected boolean stream;

    private static UnsupportedOperationException unsupported;

    static final sun.net.ext.RdmaSocketOptions rdmaOptions =

            sun.net.ext.RdmaSocketOptions.getInstance();

    static {

        java.security.AccessController.doPrivileged(

            new java.security.PrivilegedAction<>() {

                public Void run() {

                    System.loadLibrary("net");

                    System.loadLibrary("extnet");

                    return null;

                }

            });

        UnsupportedOperationException uoe = null;

        try {

            initProto();

        } catch (UnsupportedOperationException e) {

            uoe = e;

        }

        unsupported = uoe;

    }

    private static final Void checkSupported() {

        if (unsupported != null) {

            Exception e = unsupported;

            throw new UnsupportedOperationException(e.getMessage(), e);

        } else {

            return null;

        }

    }

    public RdmaSocketImpl(ProtocolFamily family) {

        this(checkSupported(), family);

    }

    private RdmaSocketImpl(Void unused, ProtocolFamily family) {

        Objects.requireNonNull(family, "null family");

        if (!(family == INET || family == INET6)) {

            throw new UnsupportedOperationException("Protocol family not supported");

        }

        if (family == INET6) {

            if (!Net.isIPv6Available()) {

                throw new UnsupportedOperationException(

                        "IPv6 not available");

            }

        }

        this.family = family;

    }

    private static volatile boolean checkedRdma;

    private static volatile boolean isRdmaAvailable;

    boolean isRdmaAvailable() {

        if (!checkedRdma) {

            isRdmaAvailable = isRdmaAvailable0();

            checkedRdma = true;

        }

        return isRdmaAvailable;

    }

    void setSocket(Socket soc) {

        this.socket = soc;

    }

    Socket getSocket() {

        return socket;

    }

    void setServerSocket(ServerSocket soc) {

        this.serverSocket = soc;

    }

    ServerSocket getServerSocket() {

        return serverSocket;

    }

    @Override

    protected abstract Set<SocketOption<?>> supportedOptions();

    protected synchronized void create(boolean stream) throws IOException {

        this.stream = stream;

        if (stream) {

            fd = new FileDescriptor();

            boolean preferIPv6 = Net.isIPv6Available() && (family != INET);

            rdmaSocketCreate(preferIPv6, true);

        }

    }

    protected void connect(String host, int port)

            throws UnknownHostException, IOException {

        boolean connected = false;

        try {

            InetAddress address = InetAddress.getByName(host);

            this.port = port;

            this.address = address;

            connectToAddress(address, port, timeout);

            connected = true;

        } finally {

            if (!connected) {

                try {

                    close();

                } catch (IOException ioe) {

                }

            }

        }

    }

    protected void connect(InetAddress address, int port) throws IOException {

        if (family == INET && !(address instanceof Inet4Address))

                throw new IllegalArgumentException("address type mismatch");

        if (family == INET6 && !(address instanceof Inet6Address))

                throw new IllegalArgumentException("address type mismatch");

        this.port = port;

        this.address = address;

        try {

            connectToAddress(address, port, timeout);

            return;

        } catch (IOException e) {

            close();

            throw e;

        }

    }

    protected void connect(SocketAddress address, int timeout)

            throws IOException {

        boolean connected = false;

        try {

            if (address == null || !(address instanceof InetSocketAddress))

                throw new IllegalArgumentException("unsupported address type");

            InetSocketAddress addr = (InetSocketAddress) address;

            InetAddress ia = addr.getAddress();

            if (family == INET && !(ia instanceof Inet4Address))

                throw new IllegalArgumentException("address type mismatch");

            if (family == INET6 && !(ia instanceof Inet6Address))

                throw new IllegalArgumentException("address type mismatch");

            if (addr.isUnresolved())

                throw new UnknownHostException(addr.getHostName());

            this.port = addr.getPort();

            this.address = addr.getAddress();

            connectToAddress(this.address, port, timeout);

            connected = true;

        } finally {

            if (!connected) {

                try {

                    close();

                } catch (IOException ioe) {

                }

            }

        }

    }

    private void connectToAddress(InetAddress address, int port, int timeout)

            throws IOException {

        if (address.isAnyLocalAddress()) {

            doConnect(InetAddress.getLocalHost(), port, timeout);

        } else {

            doConnect(address, port, timeout);

        }

    }

    @Override

    protected abstract <T> void setOption(SocketOption<T> name, T value)

            throws IOException;

    @SuppressWarnings("unchecked")

    @Override

    protected abstract <T> T getOption(SocketOption<T> name)

            throws IOException;

    public void setOption(int opt, Object val) throws SocketException {

        if (isClosedOrPending()) {

            throw new SocketException("Socket Closed");

        }

        boolean on = true;

        switch (opt) {

        case SO_TIMEOUT:

            if (val == null || (!(val instanceof Integer)))

                throw new SocketException("Bad parameter for SO_TIMEOUT");

            int tmp = ((Integer) val).intValue();

            if (tmp < 0)

                throw new IllegalArgumentException("timeout < 0");

            timeout = tmp;

            break;

        case SO_BINDADDR:

            throw new SocketException("Cannot re-bind socket");

        case TCP_NODELAY:

            if (val == null || !(val instanceof Boolean))

                throw new SocketException("bad parameter for TCP_NODELAY");

            on = ((Boolean)val).booleanValue();

            break;

        case SO_SNDBUF:

        case SO_RCVBUF:

            int value = ((Integer)val).intValue();

            int maxValue = 1024 * 1024 * 1024 - 1;   //maximum value for the buffer

            if (val == null || !(val instanceof Integer) ||

                !(value > 0)) {

                throw new SocketException("bad parameter for SO_SNDBUF " +

                                          "or SO_RCVBUF");

            }

            if (value >= maxValue)

                value = maxValue;

            break;

        case SO_REUSEADDR:

            if (val == null || !(val instanceof Boolean))

                throw new SocketException("bad parameter for SO_REUSEADDR");

            on = ((Boolean)val).booleanValue();

            if (serverSocket != null && serverSocket.isBound())

                    throw new UnsupportedOperationException(

                            "RDMA server socket cannot set " +

                            "SO_REUSEADDR after bind.");

            if (socket != null && socket.isConnected())

                    throw new UnsupportedOperationException(

                            "RDMA socket cannot set " +

                            "SO_REUSEADDR after connect.");

            break;

        default:

            throw new SocketException("unrecognized TCP option: " + opt);

        }

        socketSetOption(opt, on, val);

    }

    public Object getOption(int opt) throws SocketException {

        if (isClosedOrPending()) {

            throw new SocketException("Socket Closed");

        }

        if (opt == SO_TIMEOUT) {

            return timeout;

        }

        int ret = 0;

        switch (opt) {

        case TCP_NODELAY:

            ret = rdmaSocketGetOption(opt, null);

            return Boolean.valueOf(ret != -1);

        case SO_REUSEADDR:

            ret = rdmaSocketGetOption(opt, null);

            return Boolean.valueOf(ret != -1);

        case SO_BINDADDR:

            RdmaInetAddressContainer in = new RdmaInetAddressContainer();

            ret = rdmaSocketGetOption(opt, in);

            return in.addr;

        case SO_SNDBUF:

        case SO_RCVBUF:

            ret = rdmaSocketGetOption(opt, null);

            return ret;

        default:

            return null;

        }

    }

    protected void socketSetOption(int opt, boolean b, Object val)

            throws SocketException {

        if (opt == SocketOptions.SO_REUSEPORT &&

            !supportedOptions().contains(StandardSocketOptions.SO_REUSEPORT)) {

            throw new UnsupportedOperationException("unsupported option");

        }

        try {

            rdmaSocketSetOption(opt, b, val);

        } catch (SocketException se) {

            if (socket == null || !socket.isConnected())

                throw se;

        }

    }

    synchronized void doConnect(InetAddress address, int port, int timeout)

            throws IOException {

        try {

            acquireFD();

            boolean preferIPv6 = Net.isIPv6Available() && (family != INET);

            try {

                rdmaSocketConnect(preferIPv6, address, port, timeout);

                synchronized (fdLock) {

                    if (closePending) {

                        throw new SocketException ("Socket closed");

                    }

                }

            } finally {

                releaseFD();

            }

        } catch (IOException e) {

            close();

            throw e;

        }

    }

    private final InetAddress anyLocalAddress() throws IOException {

        if (family == INET)

            return InetAddress.getByName("0.0.0.0");

        else if (family == INET6)

            return InetAddress.getByName("::");

        else

            throw new IllegalArgumentException("Unsupported address type " + family);

    }

    protected synchronized void bind(InetAddress address, int lport)

            throws IOException {

        if (address == null)

            throw new IllegalArgumentException("address is null");

        if (address.isAnyLocalAddress())

            address = anyLocalAddress();

        if (family == INET && !(address instanceof Inet4Address))

            throw new IllegalArgumentException("address type mismatch");

        if (family == INET6 && !(address instanceof Inet6Address))

            throw new IllegalArgumentException("address type mismatch");

        boolean preferIPv6 = Net.isIPv6Available() && (family != INET);

        rdmaSocketBind(preferIPv6, address, lport);

    }

    protected synchronized void listen(int count) throws IOException {

        rdmaSocketListen(count);

    }

    protected void accept(SocketImpl s) throws IOException {

        acquireFD();

        try {

            rdmaSocketAccept(s);

        } finally {

            releaseFD();

        }

    }

    protected synchronized InputStream getInputStream() throws IOException {

        synchronized (fdLock) {

            if (isClosedOrPending())

                throw new IOException("Socket Closed");

            if (shut_rd)

                throw new IOException("Socket input is shutdown");

            if (socketInputStream == null)

                socketInputStream = new RdmaSocketInputStream(this);

        }

        return socketInputStream;

    }

    protected synchronized OutputStream getOutputStream() throws IOException {

        synchronized (fdLock) {

            if (isClosedOrPending())

                throw new IOException("Socket Closed");

            if (shut_wr)

                throw new IOException("Socket output is shutdown");

            if (socketOutputStream == null)

                socketOutputStream = new RdmaSocketOutputStream(this);

        }

        return socketOutputStream;

    }

    protected FileDescriptor getFileDescriptor() {

        return fd;

    }

    protected void setFileDescriptor(FileDescriptor fd) {

        this.fd = fd;

    }

    protected void setAddress(InetAddress address) {

        this.address = address;

    }

    void setPort(int port) {

        this.port = port;

    }

    void setLocalPort(int localport) {

        this.localport = localport;

    }

    protected synchronized int available() throws IOException {

        throw new UnsupportedOperationException(

                "unsupported socket operation");

    }

    protected void close() throws IOException {

        synchronized(fdLock) {

            if (fd != null) {

                if (fdUseCount == 0) {

                    if (closePending) {

                        return;

                    }

                    closePending = true;

                    rdmaSocketClose();

                    fd = null;

                    return;

                } else {

                    if (!closePending) {

                        closePending = true;

                        fdUseCount--;

                        rdmaSocketClose();

                    }

                }

            }

        }

    }

    void reset() throws IOException {

        if (fd != null) {

            rdmaSocketClose();

        }

        fd = null;

        postReset();

    }

    void postReset() throws IOException {

        address = null;

        port = 0;

        localport = 0;

    }

    protected void shutdownInput() throws IOException {

        if (fd != null) {

            rdmaSocketShutdown(SHUT_RD);

            if (socketInputStream != null) {

                ((RdmaSocketInputStream)socketInputStream).setEOF(true);

            }

            shut_rd = true;

        }

    }

    protected void shutdownOutput() throws IOException {

        if (fd != null) {

            rdmaSocketShutdown(SHUT_WR);

            shut_wr = true;

        }

    }

    protected boolean supportsUrgentData () {

        return true;

    }

    protected void sendUrgentData (int data) throws IOException {

        if (fd == null) {

            throw new IOException("Socket Closed");

        }

        rdmaSocketSendUrgentData(data);

    }

    FileDescriptor acquireFD() {