mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
1274 lines
33 KiB
C#
1274 lines
33 KiB
C#
using java.nio.channels;
|
|
using java.security;
|
|
using javax.net.ssl;
|
|
|
|
namespace System.Net.Sockets
|
|
{
|
|
/// <summary>
|
|
/// Summary description for GHStreamSocket.
|
|
/// </summary>
|
|
internal class GHStreamSocket : GHSocket
|
|
{
|
|
java.net.ServerSocket jServerSocket;
|
|
java.net.Socket jSocket;
|
|
java.nio.channels.ServerSocketChannel jServerSocketChannel;
|
|
java.nio.channels.SocketChannel jSocketChannel;
|
|
|
|
// This field I need because a bug in the java.nio.channels.SocketAdapter, which
|
|
// returns local port 0 if the socket is not connected (even if the socket is bound)
|
|
// so I need temporary use regular socket (not channel socket) to bind it to the
|
|
// local address and use this address in the LocalPoint property and to create the
|
|
// actual client/server channel sockets
|
|
// The bug #5076965 (SocketChannel does not report local address after binding to a wildcard )
|
|
// See: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5076965
|
|
java.net.InetSocketAddress jTempLocalSocketAddress;
|
|
|
|
public GHStreamSocket()
|
|
{
|
|
jSocketChannel = java.nio.channels.SocketChannel.open();
|
|
jSocket = jSocketChannel.socket();
|
|
}
|
|
|
|
public GHStreamSocket(java.nio.channels.SocketChannel socketChannel)
|
|
{
|
|
jSocketChannel = socketChannel;
|
|
jSocket = jSocketChannel.socket();
|
|
}
|
|
|
|
public override int GetHashCode ()
|
|
{
|
|
if (jSocket == null && jServerSocket == null)
|
|
return -1;
|
|
|
|
if (jServerSocket != null) {
|
|
return jServerSocket.ToString ().GetHashCode ();
|
|
}
|
|
|
|
return jSocket.ToString ().GetHashCode ();
|
|
}
|
|
|
|
public int Available_internal(out int error)
|
|
{
|
|
error = 0;
|
|
int r = 0;
|
|
|
|
if (jSocket == null || !jSocket.isConnected())
|
|
{
|
|
return r;
|
|
}
|
|
|
|
try
|
|
{
|
|
r = jSocket.getInputStream().available();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10054; //WSAECONNRESET (Connection reset by peer)
|
|
r = 0;
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Available_internal - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
public void Blocking_internal(bool block, out int error)
|
|
{
|
|
error = 0;
|
|
|
|
if (jSocket == null && jServerSocket == null)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (jServerSocket != null)
|
|
{
|
|
jServerSocketChannel.configureBlocking(block);
|
|
}
|
|
else
|
|
{
|
|
jSocketChannel.configureBlocking(block);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Blocking_internal - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
public EndPoint LocalEndPoint_internal(out int error)
|
|
{
|
|
error = 0;
|
|
java.net.InetSocketAddress localAddr = null;
|
|
|
|
try
|
|
{
|
|
if (jTempLocalSocketAddress != null)
|
|
{
|
|
localAddr = jTempLocalSocketAddress;
|
|
}
|
|
else if (jServerSocket != null)
|
|
{
|
|
localAddr = (java.net.InetSocketAddress)jServerSocket.getLocalSocketAddress();
|
|
}
|
|
else
|
|
{
|
|
localAddr = (java.net.InetSocketAddress)jSocket.getLocalSocketAddress();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
localAddr = null;
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during LocalEndPoint_internal - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
|
|
if (localAddr == null || localAddr.getAddress() == null || localAddr.getPort() < 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
IPHostEntry lipa = Dns.Resolve(localAddr.getHostName());
|
|
IPEndPoint ret = new IPEndPoint(lipa.AddressList[0], localAddr.getPort());
|
|
return ret;
|
|
}
|
|
|
|
public EndPoint RemoteEndPoint_internal(out int error)
|
|
{
|
|
error = 0;
|
|
java.net.InetSocketAddress remoteAddr = null;
|
|
|
|
if (jSocket == null || !jSocket.isBound())
|
|
{
|
|
return null;
|
|
}
|
|
|
|
try
|
|
{
|
|
remoteAddr = (java.net.InetSocketAddress)jSocket.getRemoteSocketAddress();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
remoteAddr = null;
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during RemoteEndPoint_internal - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
|
|
if (remoteAddr == null || remoteAddr.getAddress() == null || remoteAddr.getPort() <= 0)
|
|
{
|
|
error = 10057; //WSAENOTCONN (Socket is not connected)
|
|
return null;
|
|
}
|
|
|
|
IPHostEntry lipa = Dns.Resolve(remoteAddr.getHostName());
|
|
IPEndPoint ret = new IPEndPoint(lipa.AddressList[0], remoteAddr.getPort());
|
|
return ret;
|
|
}
|
|
|
|
public GHSocket Accept_internal(out int error)
|
|
{
|
|
error = 0;
|
|
|
|
if (jServerSocket == null)
|
|
{
|
|
throw new InvalidOperationException("You must call Bind and Listen before calling Accept.");
|
|
}
|
|
|
|
try
|
|
{
|
|
/*
|
|
If this channel is in non-blocking mode then this method will immediately
|
|
return null if there are no pending connections.
|
|
Otherwise it will block indefinitely until a new connection is
|
|
available or an I/O error occurs.
|
|
*/
|
|
java.nio.channels.SocketChannel acceptedSocket = jServerSocketChannel.accept();
|
|
if (acceptedSocket == null)
|
|
{
|
|
error = 10035; //WSAEWOULDBLOCK (Resource temporarily unavailable)
|
|
#if DEBUG
|
|
Console.WriteLine("The Accept_internal is in non-blocking mode and no pending connections are available");
|
|
#endif
|
|
return null;
|
|
}
|
|
|
|
return new GHStreamSocket(acceptedSocket);
|
|
}
|
|
catch (AsynchronousCloseException) {
|
|
error = 10004;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10061; //WSAECONNREFUSED (Connection refused)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Accept_internal - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public void Bind_internal(EndPoint sa, out int error)
|
|
{
|
|
error = 0;
|
|
IPEndPoint addr = sa as IPEndPoint;
|
|
if (addr == null)
|
|
{
|
|
error = 10044; //WSAESOCKTNOSUPPORT (Socket type not supported)
|
|
return;
|
|
}
|
|
|
|
if (jSocket == null || jSocket.isBound() || jSocket.isConnected() || jSocketChannel.isConnectionPending())
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
// This code I need because a bug in the java.nio.channels.SocketAdapter, which
|
|
// returns local port 0 if the socket is not connected (even if the socket is bound)
|
|
// so I need temporary use regular socket (not channel socket) to bind it to the
|
|
// local address and use this address in the LocalPoint property and to create the
|
|
// actual client/server channel sockets
|
|
// The bug #5076965 (SocketChannel does not report local address after binding to a wildcard )
|
|
// See: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5076965
|
|
java.net.Socket jTempSocket = new java.net.Socket();
|
|
jTempSocket.bind(new java.net.InetSocketAddress(java.net.InetAddress.getByName(addr.Address.ToString()),
|
|
addr.Port));
|
|
jTempLocalSocketAddress = (java.net.InetSocketAddress)jTempSocket.getLocalSocketAddress();
|
|
jTempSocket.close();
|
|
jSocket.bind(jTempLocalSocketAddress);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10048; //WSAEADDRINUSE (Address already in use)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Bind_internal - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
public void Close_internal(out int error)
|
|
{
|
|
error = 0;
|
|
|
|
if (jServerSocket != null)
|
|
{
|
|
try
|
|
{
|
|
jServerSocket.close();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Close_internal jServerSocket - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
try
|
|
{
|
|
jServerSocketChannel.close();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Close_internal jServerSocketChannel - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
jServerSocket = null;
|
|
jServerSocketChannel = null;
|
|
}
|
|
else if (jSocket != null)
|
|
{
|
|
try
|
|
{
|
|
jSocket.close();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Close_internal jSocket - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
try
|
|
{
|
|
jSocketChannel.close();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Close_internal jSocketChannel - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
jSocket = null;
|
|
jSocketChannel = null;
|
|
}
|
|
}
|
|
|
|
public void Connect_internal(EndPoint sa, out int error)
|
|
{
|
|
error = 0;
|
|
|
|
IPEndPoint addr = sa as IPEndPoint;
|
|
if (addr == null)
|
|
{
|
|
error = 10044; //WSAESOCKTNOSUPPORT (Socket type not supported)
|
|
return;
|
|
}
|
|
|
|
if (jSocket == null)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
return;
|
|
}
|
|
|
|
if (jSocket.isConnected() || jSocketChannel.isConnectionPending())
|
|
{
|
|
error = 10056; //WSAEISCONN (Socket is already connected)
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
/*
|
|
If this channel is in non-blocking mode then an invocation of this method
|
|
initiates a non-blocking connection operation. If the connection is
|
|
established immediately, as can happen with a local connection, then this
|
|
method returns true. Otherwise this method returns false.
|
|
If this channel is in blocking mode then an invocation of this method
|
|
will block until the connection is established or an I/O error occurs.
|
|
*/
|
|
bool status = jSocketChannel.connect(new java.net.InetSocketAddress(
|
|
java.net.InetAddress.getByName(addr.Address.ToString()),
|
|
addr.Port));
|
|
if (!status)
|
|
{
|
|
error = 10035; //WSAEWOULDBLOCK (Resource temporarily unavailable)
|
|
}
|
|
}
|
|
catch (java.nio.channels.AlreadyConnectedException ae)
|
|
{
|
|
error = 10056; //WSAEISCONN (Socket is already connected)
|
|
}
|
|
catch (java.nio.channels.ConnectionPendingException cpe)
|
|
{
|
|
error = 10036; //WSAEINPROGRESS (Operation now in progress)
|
|
}
|
|
catch (java.nio.channels.UnresolvedAddressException uae)
|
|
{
|
|
error = 10039; //WSAEDESTADDRREQ (Destination address required)
|
|
}
|
|
catch (java.nio.channels.UnsupportedAddressTypeException uate)
|
|
{
|
|
error = 10041; //WSAEPROTOTYPE (Protocol wrong type for socket)
|
|
}
|
|
catch (AsynchronousCloseException) {
|
|
error = 10004;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10061; //WSAECONNREFUSED (Connection refused)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Connect_internal - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
public void Listen_internal(int backlog, out int error)
|
|
{
|
|
error = 0;
|
|
|
|
if (jSocket == null || !jSocket.isBound())
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
return;
|
|
}
|
|
|
|
if (jSocket.isConnected() || jSocketChannel.isConnectionPending())
|
|
{
|
|
error = 10056; //WSAEISCONN (Socket is already connected)
|
|
return;
|
|
}
|
|
|
|
bool blockMode = jSocketChannel.isBlocking();
|
|
bool reuseAddr = jSocket.getReuseAddress();
|
|
|
|
try
|
|
{
|
|
jSocket.close();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Listen_internal close old jSocket - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
|
|
try
|
|
{
|
|
jSocketChannel.close();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Listen_internal close old jSocketChannel - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
|
|
jSocket = null;
|
|
jSocketChannel = null;
|
|
|
|
try
|
|
{
|
|
jServerSocketChannel = java.nio.channels.ServerSocketChannel.open();
|
|
jServerSocket = jServerSocketChannel.socket();
|
|
jServerSocket.bind(jTempLocalSocketAddress, backlog);
|
|
jServerSocketChannel.configureBlocking(blockMode);
|
|
jServerSocket.setReuseAddress(reuseAddr);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10048; //WSAEADDRINUSE (Address already in use)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Listen_internal create server socket - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
public bool Poll_internal (SelectMode mode, int timeout, Socket source, out int error)
|
|
{
|
|
error = 0;
|
|
|
|
if (mode == SelectMode.SelectError && !jSocketChannel.isConnectionPending())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
java.nio.channels.Selector selector = java.nio.channels.Selector.open();
|
|
RegisterSelector(selector, ((mode == SelectMode.SelectRead)?0:1), source, out error);
|
|
|
|
if (error != 0)
|
|
{
|
|
error = 0;
|
|
GHSocketFactory.CloseSelector(selector);
|
|
return (mode == SelectMode.SelectError);
|
|
}
|
|
|
|
bool retVal = false;
|
|
|
|
long timeOutMillis = 1;
|
|
if (timeout < 0)
|
|
{
|
|
timeOutMillis = 0;
|
|
}
|
|
else if (timeout > 999)
|
|
{
|
|
timeOutMillis = (long)(timeout / 1000);
|
|
}
|
|
|
|
int readyCount = 0;
|
|
try
|
|
{
|
|
readyCount = selector.select(timeOutMillis);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Poll_internal selector.select - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
|
|
if (readyCount > 0)
|
|
{
|
|
if (jSocket != null && jSocketChannel.isConnectionPending())
|
|
{
|
|
bool status = false;
|
|
try
|
|
{
|
|
status = jSocketChannel.finishConnect();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Poll_internal, finishConnect - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
if (status)
|
|
{
|
|
retVal = (mode != SelectMode.SelectError);
|
|
}
|
|
else
|
|
{
|
|
retVal = (mode == SelectMode.SelectError);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retVal = true;
|
|
}
|
|
}
|
|
|
|
GHSocketFactory.CloseSelector(selector);
|
|
|
|
return retVal;
|
|
}
|
|
|
|
public void RegisterSelector(java.nio.channels.Selector selector, int mode, Socket source, out int error)
|
|
{
|
|
error = 0;
|
|
if (jServerSocket != null)
|
|
{
|
|
// only accept operation, which included to the read list, is allowed for server sockets
|
|
if (mode != 0)
|
|
{
|
|
// error = 10038; //WSAENOTSOCK (Socket operation on nonsocket)
|
|
#if DEBUG
|
|
Console.WriteLine("RegisterSelector, invalid mode {0} for the server socket", mode);
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (jServerSocketChannel.isBlocking())
|
|
{
|
|
/*
|
|
A channel must be placed into non-blocking mode before being registered
|
|
with a selector, and may not be returned to blocking mode until it has been
|
|
deregistered.
|
|
*/
|
|
jServerSocketChannel.configureBlocking(false);
|
|
}
|
|
|
|
jServerSocketChannel.register(selector, java.nio.channels.SelectionKey.OP_ACCEPT, source);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during RegisterSelector, register server socket - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
int ops = java.nio.channels.SelectionKey.OP_READ;
|
|
if (mode > 0)
|
|
{
|
|
if (jSocketChannel.isConnectionPending())
|
|
{
|
|
ops = java.nio.channels.SelectionKey.OP_CONNECT;
|
|
}
|
|
else
|
|
{
|
|
ops = java.nio.channels.SelectionKey.OP_WRITE;
|
|
}
|
|
}
|
|
|
|
if (jSocketChannel.isBlocking())
|
|
{
|
|
/*
|
|
A channel must be placed into non-blocking mode before being registered
|
|
with a selector, and may not be returned to blocking mode until it has been
|
|
deregistered.
|
|
*/
|
|
jSocketChannel.configureBlocking(false);
|
|
}
|
|
|
|
jSocketChannel.register(selector, ops, source);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during RegisterSelector, register client socket - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool CheckConnectionFinished()
|
|
{
|
|
bool status = true;
|
|
if (jSocket != null && jSocketChannel.isConnectionPending())
|
|
{
|
|
try
|
|
{
|
|
status = jSocketChannel.finishConnect();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
status = false;
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Poll_internal, finishConnect - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
public int Receive_internal(byte[] buffer, int offset, int count, SocketFlags flags,
|
|
out int error)
|
|
{
|
|
error = 0;
|
|
int ret = 0;
|
|
|
|
if (jSocket == null)
|
|
{
|
|
error = 10057; //WSAENOTCONN (Socket is not connected)
|
|
return ret;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (jSocketChannel.isConnectionPending())
|
|
{
|
|
bool status = jSocketChannel.finishConnect();
|
|
if (!status)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
#if DEBUG
|
|
Console.WriteLine("Receive_internal, jSocketChannel.finishConnect return false");
|
|
#endif
|
|
return 0;
|
|
}
|
|
}
|
|
else if (!jSocketChannel.isConnected())
|
|
{
|
|
error = 10057; //WSAENOTCONN (Socket is not connected)
|
|
return ret;
|
|
}
|
|
|
|
java.nio.ByteBuffer readBuff = java.nio.ByteBuffer.wrap(vmw.common.TypeUtils.ToSByteArray(buffer), offset, count);
|
|
ret = jSocketChannel.read(readBuff);
|
|
if (ret < 0) ret = 0;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10054; //WSAECONNRESET (Connection reset by peer)
|
|
ret = 0;
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Receive_internal - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
|
|
if (ret == 0 && !jSocketChannel.isBlocking())
|
|
{
|
|
error = 10035; //WSAEWOULDBLOCK (Resource temporarily unavailable)
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public int RecvFrom_internal(byte[] buffer, int offset, int count, SocketFlags flags,
|
|
ref SocketAddress sockaddr, out int error)
|
|
{
|
|
return Receive_internal(buffer, offset, count, flags, out error);
|
|
}
|
|
|
|
public int Send_internal(byte[] buf, int offset, int count, SocketFlags flags,
|
|
out int error)
|
|
{
|
|
error = 0;
|
|
int ret = 0;
|
|
|
|
if (jSocket == null)
|
|
{
|
|
error = 10057; //WSAENOTCONN (Socket is not connected)
|
|
return ret;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (jSocketChannel.isConnectionPending())
|
|
{
|
|
bool status = jSocketChannel.finishConnect();
|
|
if (!status)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
#if DEBUG
|
|
Console.WriteLine("Send_internal, jSocketChannel.finishConnect return false");
|
|
#endif
|
|
return 0;
|
|
}
|
|
}
|
|
else if (!jSocketChannel.isConnected())
|
|
{
|
|
error = 10057; //WSAENOTCONN (Socket is not connected)
|
|
return ret;
|
|
}
|
|
|
|
java.nio.ByteBuffer writeBuff = java.nio.ByteBuffer.wrap(vmw.common.TypeUtils.ToSByteArray(buf), offset, count);
|
|
ret = jSocketChannel.write(writeBuff);
|
|
if (ret < 0) ret = 0;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10054; //WSAECONNRESET (Connection reset by peer)
|
|
ret = 0;
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Send_internal - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
|
|
if (ret == 0 && !jSocketChannel.isBlocking())
|
|
{
|
|
error = 10035; //WSAEWOULDBLOCK (Resource temporarily unavailable)
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public int SendTo_internal(byte[] buffer, int offset, int count,
|
|
SocketFlags flags, SocketAddress sa, out int error)
|
|
{
|
|
return Send_internal(buffer, offset, count, flags, out error);
|
|
}
|
|
|
|
public void SetSocketOption_internal (SocketOptionLevel level,
|
|
SocketOptionName name, object obj_val,
|
|
byte [] byte_val, int int_val, out int error)
|
|
{
|
|
error = 0;
|
|
|
|
if (byte_val != null)
|
|
{
|
|
error = -1;
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
if (jSocket == null && jServerSocket == null)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
return;
|
|
}
|
|
|
|
switch (level)
|
|
{
|
|
case SocketOptionLevel.IPv6:
|
|
error = 10042; //WSAENOPROTOOPT (Bad protocol option)
|
|
return;
|
|
case SocketOptionLevel.IP:
|
|
if (name != SocketOptionName.NoDelay)
|
|
{
|
|
error = 10042; //WSAENOPROTOOPT (Bad protocol option)
|
|
return;
|
|
}
|
|
break;
|
|
case SocketOptionLevel.Udp:
|
|
if (name == SocketOptionName.NoDelay)
|
|
{
|
|
error = 10042; //WSAENOPROTOOPT (Bad protocol option)
|
|
}
|
|
else
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
}
|
|
return;
|
|
case SocketOptionLevel.Tcp:
|
|
if (name != SocketOptionName.NoDelay)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
|
|
try
|
|
{
|
|
bool bval = false;
|
|
int ival = 0;
|
|
switch (name)
|
|
{
|
|
case SocketOptionName.DontLinger:
|
|
jSocket.setSoLinger(false, 0);
|
|
break;
|
|
case SocketOptionName.Linger:
|
|
LingerOption lval = obj_val as LingerOption;
|
|
if (lval != null)
|
|
{
|
|
jSocket.setSoLinger(lval.Enabled, lval.LingerTime);
|
|
}
|
|
else
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
}
|
|
break;
|
|
case SocketOptionName.KeepAlive:
|
|
if (obj_val != null)
|
|
{
|
|
bval = ((int)obj_val == 0)?false:true;
|
|
}
|
|
else
|
|
{
|
|
bval = (int_val == 0)?false:true;
|
|
}
|
|
jSocket.setKeepAlive(bval);
|
|
break;
|
|
case SocketOptionName.NoDelay:
|
|
if (obj_val != null)
|
|
{
|
|
bval = ((int)obj_val == 0)?false:true;
|
|
}
|
|
else
|
|
{
|
|
bval = (int_val == 0)?false:true;
|
|
}
|
|
jSocket.setTcpNoDelay(bval);
|
|
break;
|
|
case SocketOptionName.ReceiveBuffer:
|
|
ival = int_val;
|
|
if (obj_val != null)
|
|
{
|
|
ival = (int) obj_val;
|
|
}
|
|
if (jServerSocket != null)
|
|
{
|
|
jServerSocket.setReceiveBufferSize(ival);
|
|
}
|
|
else
|
|
{
|
|
jSocket.setReceiveBufferSize(ival);
|
|
}
|
|
break;
|
|
case SocketOptionName.ReceiveTimeout:
|
|
ival = int_val;
|
|
if (obj_val != null)
|
|
{
|
|
ival = (int) obj_val;
|
|
}
|
|
if (jServerSocket != null)
|
|
{
|
|
jServerSocket.setSoTimeout(ival);
|
|
}
|
|
else
|
|
{
|
|
jSocket.setSoTimeout(ival);
|
|
}
|
|
break;
|
|
case SocketOptionName.ReuseAddress:
|
|
if (obj_val != null)
|
|
{
|
|
bval = ((int)obj_val == 0)?false:true;
|
|
}
|
|
else
|
|
{
|
|
bval = (int_val == 0)?false:true;
|
|
}
|
|
if (jServerSocket != null)
|
|
{
|
|
jServerSocket.setReuseAddress(bval);
|
|
}
|
|
else
|
|
{
|
|
jSocket.setReuseAddress(bval);
|
|
}
|
|
break;
|
|
case SocketOptionName.SendBuffer:
|
|
ival = int_val;
|
|
if (obj_val != null)
|
|
{
|
|
ival = (int) obj_val;
|
|
}
|
|
jSocket.setSendBufferSize(ival);
|
|
break;
|
|
case SocketOptionName.OutOfBandInline:
|
|
if (obj_val != null)
|
|
{
|
|
bval = ((int)obj_val == 0)?false:true;
|
|
}
|
|
else
|
|
{
|
|
bval = (int_val == 0)?false:true;
|
|
}
|
|
jSocket.setOOBInline(bval);
|
|
break;
|
|
default:
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
obj_val = null;
|
|
}
|
|
}
|
|
|
|
public void GetSocketOption_obj_internal(SocketOptionLevel level, SocketOptionName name,
|
|
out object obj_val, out int error)
|
|
{
|
|
obj_val = null;
|
|
error = 0;
|
|
|
|
if (jSocket == null && jServerSocket == null)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
return;
|
|
}
|
|
|
|
switch (level)
|
|
{
|
|
case SocketOptionLevel.IPv6:
|
|
error = 10042; //WSAENOPROTOOPT (Bad protocol option)
|
|
return;
|
|
case SocketOptionLevel.IP:
|
|
if (name != SocketOptionName.NoDelay)
|
|
{
|
|
error = 10042; //WSAENOPROTOOPT (Bad protocol option)
|
|
return;
|
|
}
|
|
break;
|
|
case SocketOptionLevel.Udp:
|
|
if (name == SocketOptionName.NoDelay)
|
|
{
|
|
error = 10042; //WSAENOPROTOOPT (Bad protocol option)
|
|
}
|
|
else
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
}
|
|
return;
|
|
case SocketOptionLevel.Tcp:
|
|
if (name != SocketOptionName.NoDelay)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
|
|
try
|
|
{
|
|
bool bval = false;
|
|
int ival = 0;
|
|
switch (name)
|
|
{
|
|
case SocketOptionName.DontLinger:
|
|
ival = jSocket.getSoLinger();
|
|
if (ival == -1)
|
|
{
|
|
obj_val = 1;
|
|
}
|
|
else
|
|
{
|
|
obj_val = 0;
|
|
}
|
|
break;
|
|
case SocketOptionName.Linger:
|
|
ival = jSocket.getSoLinger();
|
|
if (ival == -1)
|
|
{
|
|
ival = 0;
|
|
}
|
|
LingerOption ret = new LingerOption((ival != 0), ival);
|
|
obj_val = ret;
|
|
break;
|
|
case SocketOptionName.KeepAlive:
|
|
bval = jSocket.getKeepAlive();
|
|
obj_val = ((bval)?1:0);
|
|
break;
|
|
case SocketOptionName.NoDelay:
|
|
bval = jSocket.getTcpNoDelay();
|
|
obj_val = ((bval)?1:0);
|
|
break;
|
|
case SocketOptionName.ReceiveBuffer:
|
|
if (jServerSocket != null)
|
|
{
|
|
ival = jServerSocket.getReceiveBufferSize();
|
|
}
|
|
else
|
|
{
|
|
ival = jSocket.getReceiveBufferSize();
|
|
}
|
|
obj_val = ival;
|
|
break;
|
|
case SocketOptionName.ReceiveTimeout:
|
|
if (jServerSocket != null)
|
|
{
|
|
ival = jServerSocket.getSoTimeout();
|
|
}
|
|
else
|
|
{
|
|
ival = jSocket.getSoTimeout();
|
|
}
|
|
obj_val = ival;
|
|
break;
|
|
case SocketOptionName.ReuseAddress:
|
|
if (jServerSocket != null)
|
|
{
|
|
bval = jServerSocket.getReuseAddress();
|
|
}
|
|
else
|
|
{
|
|
bval = jSocket.getReuseAddress();
|
|
}
|
|
obj_val = ((bval)?1:0);
|
|
break;
|
|
case SocketOptionName.SendBuffer:
|
|
ival = jSocket.getSendBufferSize();
|
|
obj_val = ival;
|
|
break;
|
|
case SocketOptionName.OutOfBandInline:
|
|
bval = jSocket.getOOBInline();
|
|
obj_val = ((bval)?1:0);
|
|
break;
|
|
default:
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
obj_val = null;
|
|
}
|
|
}
|
|
|
|
public void GetSocketOption_arr_internal(SocketOptionLevel level, SocketOptionName name,
|
|
ref byte[] byte_val, out int error)
|
|
{
|
|
error = -1;
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public int WSAIoctl (int ioctl_code, byte [] input, byte [] output, out int error)
|
|
{
|
|
error = -1;
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public void Shutdown_internal(SocketShutdown how, out int error)
|
|
{
|
|
error = 0;
|
|
|
|
if (jServerSocket != null || jSocket == null || !jSocket.isConnected())
|
|
{
|
|
error = 10057; //WSAENOTCONN (Socket is not connected)
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
switch (how)
|
|
{
|
|
case SocketShutdown.Receive:
|
|
jSocket.shutdownInput();
|
|
break;
|
|
case SocketShutdown.Send:
|
|
jSocket.shutdownOutput();
|
|
break;
|
|
case SocketShutdown.Both:
|
|
jSocket.shutdownInput();
|
|
jSocket.shutdownOutput();
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
error = 10022; //WSAEINVAL (Invalid argument)
|
|
#if DEBUG
|
|
Console.WriteLine("Caught exception during Shutdown_internal - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
private java.io.FileInputStream searchDefaultCacerts()
|
|
{
|
|
try
|
|
{
|
|
string javaHome = java.lang.System.getProperty("java.home");
|
|
if(javaHome == null)
|
|
return null;
|
|
|
|
string keyStorePath = javaHome + "/lib/security/cacerts";
|
|
//Console.WriteLine("keyStorePath = {0}", keyStorePath);
|
|
|
|
java.io.File f = new java.io.File(keyStorePath);
|
|
if(!f.exists())
|
|
return null;
|
|
return new java.io.FileInputStream(f);
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
#if DEBUG
|
|
//todo log it
|
|
Console.WriteLine(e.GetType() + ":" + e.Message + "\n" + e.StackTrace);
|
|
#endif
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private SSLSocketFactory getSSLSocketFactory()
|
|
{
|
|
SSLSocketFactory factory = null;
|
|
|
|
try
|
|
{
|
|
//reading the keyStore path and password from the environment properties
|
|
string keyStorePath = java.lang.System.getProperty("javax.net.ssl.keyStore");
|
|
java.io.FileInputStream keyStoreStream = null;
|
|
if (keyStorePath != null)
|
|
{
|
|
java.io.File file = new java.io.File(keyStorePath);
|
|
if(file.exists())
|
|
keyStoreStream = new java.io.FileInputStream(file);
|
|
else
|
|
keyStoreStream = searchDefaultCacerts();
|
|
}
|
|
else
|
|
keyStoreStream = searchDefaultCacerts();
|
|
|
|
string keyStorePassWord = java.lang.System.getProperty("javax.net.ssl.keyStorePassword");
|
|
if (keyStorePassWord == null)
|
|
keyStorePassWord = "changeit";
|
|
char[] passphrase = keyStorePassWord.ToCharArray();
|
|
|
|
//initiating SSLContext
|
|
SSLContext ctx = SSLContext.getInstance("TLS");
|
|
KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
|
|
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
|
|
KeyStore ks = KeyStore.getInstance("JKS");
|
|
if (keyStoreStream != null)
|
|
ks.load(keyStoreStream,passphrase);
|
|
else
|
|
ks.load(null,null);
|
|
kmf.init(ks, passphrase);
|
|
tmf.init(ks);
|
|
ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
|
|
|
|
factory = ctx.getSocketFactory();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
factory = null;
|
|
#if DEBUG
|
|
Console.WriteLine("Can't get SSL Socket Factory, the exception is {0}, {1}", e.GetType(), e.Message);
|
|
#endif
|
|
}
|
|
|
|
return factory;
|
|
}
|
|
|
|
public GHSocket ChangeToSSL(EndPoint remote_end)
|
|
{
|
|
if (jSocket == null)
|
|
{
|
|
throw new InvalidOperationException("The underlying socket is null");
|
|
}
|
|
|
|
if (!jSocketChannel.isBlocking())
|
|
{
|
|
throw new NotImplementedException("The SSL Socket for non-blocking mode is not supported");
|
|
}
|
|
|
|
SSLSocketFactory factory = getSSLSocketFactory();
|
|
if (factory == null)
|
|
{
|
|
throw new ApplicationException("Can't get SSL Socket Factory");
|
|
}
|
|
|
|
int err;
|
|
|
|
// The problem with local address, when I closed the socket and try to create the new one
|
|
// bounded to the given local address, I receive exception "Address already in use"
|
|
IPEndPoint localEndPoint = null;
|
|
// IPEndPoint localEndPoint = (IPEndPoint) LocalEndPoint_internal(out err);
|
|
// if (err != 0)
|
|
// localEndPoint = null;
|
|
|
|
IPEndPoint remoteEndPoint = remote_end as IPEndPoint;
|
|
if (remoteEndPoint == null)
|
|
{
|
|
remoteEndPoint = (IPEndPoint) RemoteEndPoint_internal(out err);
|
|
if (err != 0)
|
|
remoteEndPoint = null;
|
|
}
|
|
|
|
java.net.Socket sslSocket = null;
|
|
try
|
|
{
|
|
if (remoteEndPoint != null)
|
|
{
|
|
if (localEndPoint != null)
|
|
{
|
|
sslSocket = factory.createSocket(
|
|
java.net.InetAddress.getByName(remoteEndPoint.Address.ToString()),
|
|
remoteEndPoint.Port,
|
|
java.net.InetAddress.getByName(localEndPoint.Address.ToString()),
|
|
localEndPoint.Port);
|
|
}
|
|
else
|
|
{
|
|
sslSocket = factory.createSocket(
|
|
jSocket,
|
|
remoteEndPoint.Address.ToString(),
|
|
remoteEndPoint.Port,
|
|
false);
|
|
}
|
|
|
|
if (sslSocket != null)
|
|
{
|
|
String[] protocols = { "TLSv1", "SSLv3" };
|
|
((SSLSocket)sslSocket).setUseClientMode(true);
|
|
((SSLSocket)sslSocket).startHandshake();
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
sslSocket = factory.createSocket();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
sslSocket = null;
|
|
#if DEBUG
|
|
Console.WriteLine("Can't create SSL Socket, the exception is {0}, {1}", e.GetType(), e.Message);
|
|
#endif
|
|
}
|
|
|
|
if (sslSocket == null)
|
|
{
|
|
// throw new ApplicationException("Can't create SSL Socket");
|
|
// it is important to the Socket class to distinguish if the underlying
|
|
// handle (GHSocket) is still valid and can be used as non-SSL, or it is already
|
|
// closed by this function and can't be used any more.
|
|
return null;
|
|
}
|
|
|
|
/*
|
|
string[] arr = ((SSLSocket)sslSocket).getEnabledProtocols();
|
|
if (arr != null)
|
|
{
|
|
foreach (string s in arr)
|
|
Console.WriteLine("s:"+s);
|
|
}
|
|
string [] arr1 = ((SSLSocket)sslSocket).getEnabledCipherSuites();
|
|
if (arr1 != null)
|
|
{
|
|
foreach (string s in arr1)
|
|
Console.WriteLine("s:"+s);
|
|
}
|
|
*/
|
|
|
|
return new GHStreamSocketSSL(sslSocket);
|
|
}
|
|
}
|
|
}
|