public void TestCallbackServer()
{
var callbackServer = new CallbackServer(_mockJvm.Object, false);
var callbackHandler = new TestCallbackHandler();
callbackHandler.Id = callbackServer.RegisterCallback(callbackHandler);
Assert.Equal(1, callbackHandler.Id);
using ISocketWrapper callbackSocket = SocketFactory.CreateSocket();
callbackServer.Run(callbackSocket);
int connectionNumber = 2;
var clientSockets = new ISocketWrapper[connectionNumber];
for (int i = 0; i < connectionNumber; ++i)
{
var ipEndpoint = (IPEndPoint)callbackSocket.LocalEndPoint;
ISocketWrapper clientSocket = SocketFactory.CreateSocket();
clientSockets[i] = clientSocket;
clientSocket.Connect(ipEndpoint.Address, ipEndpoint.Port);
WriteAndReadTestData(clientSocket, callbackHandler, i);
}
Assert.Equal(connectionNumber, callbackServer.CurrentNumConnections);
IOrderedEnumerable <int> actualValues = callbackHandler.Inputs.OrderBy(i => i);
IEnumerable <int> expectedValues = Enumerable
.Range(0, connectionNumber)
.Select(i => callbackHandler.Apply(i))
.OrderBy(i => i);
Assert.True(expectedValues.SequenceEqual(actualValues));
}
public void TestInvalidSocketStream()
{
Assert.Throws <ArgumentNullException>(() => new SocketStream((SaeaSocketWrapper)null));
Assert.Throws <ArgumentNullException>(() => new SocketStream((RioSocketWrapper)null));
Environment.SetEnvironmentVariable(ConfigurationService.CSharpSocketTypeEnvName, "Saea");
SocketFactory.SocketWrapperType = SocketWrapperType.None;
using (var socket = SocketFactory.CreateSocket())
using (var stream = new SocketStream((SaeaSocketWrapper)socket))
{
// Verify SocketStream
Assert.IsTrue(stream.CanRead);
Assert.IsTrue(stream.CanWrite);
Assert.IsFalse(stream.CanSeek);
long lengh = 10;
Assert.Throws <NotSupportedException>(() => lengh = stream.Length);
Assert.Throws <NotSupportedException>(() => stream.Position = lengh);
Assert.Throws <NotSupportedException>(() => lengh = stream.Position);
Assert.Throws <NotSupportedException>(() => stream.Seek(lengh, SeekOrigin.Begin));
Assert.Throws <NotSupportedException>(() => stream.SetLength(lengh));
}
Environment.SetEnvironmentVariable(ConfigurationService.CSharpSocketTypeEnvName, string.Empty);
SocketFactory.SocketWrapperType = SocketWrapperType.None;
}
private static void CreateAndVerifyConnection(ISocketWrapper daemonSocket)
{
var ipEndpoint = (IPEndPoint)daemonSocket.LocalEndPoint;
int port = ipEndpoint.Port;
ISocketWrapper clientSocket = SocketFactory.CreateSocket();
clientSocket.Connect(ipEndpoint.Address, port);
// Now process the bytes flowing in from the client.
PayloadWriter payloadWriter = new PayloadWriterFactory().Create();
payloadWriter.WriteTestData(clientSocket.OutputStream);
List <object[]> rowsReceived = PayloadReader.Read(clientSocket.InputStream);
// Validate rows received.
Assert.Equal(10, rowsReceived.Count);
for (int i = 0; i < 10; ++i)
{
// Two UDFs registered, thus expecting two columns.
// Refer to TestData.GetDefaultCommandPayload().
object[] row = rowsReceived[i];
Assert.Equal(2, rowsReceived[i].Length);
Assert.Equal($"udf2 udf1 {i}", row[0]);
Assert.Equal(i + i, row[1]);
}
}
private static ISocketWrapper InitializeSocket(int javaPort)
{
var socket = SocketFactory.CreateSocket();
socket.Connect(IPAddress.Loopback, javaPort);
return(socket);
}
internal static int RunJob(IRDDProxy rdd)
{
var mockRdd = (rdd as MockRddProxy);
IEnumerable <byte[]> result = mockRdd.pickle ? mockRdd.result.Cast <byte[]>() :
mockRdd.result.Select(x =>
{
var ms = new MemoryStream();
formatter.Serialize(ms, x);
return(ms.ToArray());
});
var listener = SocketFactory.CreateSocket();
listener.Listen();
Task.Run(() =>
{
using (var socket = listener.Accept())
using (var ns = socket.GetStream())
{
foreach (var item in result)
{
SerDe.Write(ns, item.Length);
SerDe.Write(ns, item);
}
ns.Flush();
}
});
return((listener.LocalEndPoint as IPEndPoint).Port);
}
/// <summary>
/// Create new socket to simulate interaction between JVM and C#
/// </summary>
/// <param name="s"></param>
private ISocketWrapper CreateSocket(int serverPort)
{
var socket = SocketFactory.CreateSocket();
socket.Connect(IPAddress.Loopback, serverPort, null);
return(socket);
}
internal void Run(int port)
{
try
{
string secret = Utils.SettingUtils.GetWorkerFactorySecret();
s_logger.LogInfo($"RunSimpleWorker() is starting with port = {port}.");
ISocketWrapper socket = SocketFactory.CreateSocket();
socket.Connect(IPAddress.Loopback, port, secret);
if ((_version.Major == 3 && _version.Minor >= 2) || _version.Major > 3)
{
int pid = Process.GetCurrentProcess().Id;
SerDe.Write(socket.OutputStream, pid);
socket.OutputStream.Flush();
}
new TaskRunner(0, socket, false, _version).Run();
}
catch (Exception e)
{
s_logger.LogError("RunSimpleWorker() failed with exception:");
s_logger.LogException(e);
Environment.Exit(-1);
}
s_logger.LogInfo("RunSimpleWorker() finished successfully");
}
public void TestsSimpleWorkerTaskRunners(string version)
{
using ISocketWrapper serverListener = SocketFactory.CreateSocket();
var ipEndpoint = (IPEndPoint)serverListener.LocalEndPoint;
serverListener.Listen();
var typedVersion = new Version(version);
var simpleWorker = new SimpleWorker(typedVersion);
Task clientTask = Task.Run(() => simpleWorker.Run(ipEndpoint.Port));
PayloadWriter payloadWriter = new PayloadWriterFactory().Create(typedVersion);
using (ISocketWrapper serverSocket = serverListener.Accept())
{
if ((typedVersion.Major == 3 && typedVersion.Minor >= 2) || typedVersion.Major > 3)
{
int pid = SerDe.ReadInt32(serverSocket.InputStream);
}
TaskRunnerTests.TestTaskRunnerReadWrite(serverSocket, payloadWriter);
}
Assert.True(clientTask.Wait(5000));
}
/// <summary>
/// Reads the given stream to construct a BroadcastVariables object.
/// </summary>
/// <param name="stream">The stream to read from</param>
/// <returns>BroadcastVariables object</returns>
internal BroadcastVariables Process(Stream stream)
{
var broadcastVars = new BroadcastVariables();
ISocketWrapper socket = null;
broadcastVars.DecryptionServerNeeded = SerDe.ReadBool(stream);
broadcastVars.Count = Math.Max(SerDe.ReadInt32(stream), 0);
if (broadcastVars.DecryptionServerNeeded)
{
broadcastVars.DecryptionServerPort = SerDe.ReadInt32(stream);
broadcastVars.Secret = SerDe.ReadString(stream);
if (broadcastVars.Count > 0)
{
socket = SocketFactory.CreateSocket();
socket.Connect(
IPAddress.Loopback,
broadcastVars.DecryptionServerPort,
broadcastVars.Secret);
}
}
var formatter = new BinaryFormatter();
for (int i = 0; i < broadcastVars.Count; ++i)
{
long bid = SerDe.ReadInt64(stream);
if (bid >= 0)
{
if (broadcastVars.DecryptionServerNeeded)
{
long readBid = SerDe.ReadInt64(socket.InputStream);
if (bid != readBid)
{
throw new Exception("The Broadcast Id received from the encryption " +
$"server {readBid} is different from the Broadcast Id received " +
$"from the payload {bid}.");
}
object value = formatter.Deserialize(socket.InputStream);
BroadcastRegistry.Add(bid, value);
}
else
{
string path = SerDe.ReadString(stream);
using FileStream fStream =
File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);
object value = formatter.Deserialize(fStream);
BroadcastRegistry.Add(bid, value);
}
}
else
{
bid = -bid - 1;
BroadcastRegistry.Remove(bid);
}
}
socket?.Dispose();
return(broadcastVars);
}
public void TestJvmCallbackClientProperty()
{
var server = new CallbackServer(_mockJvm.Object, run: false);
Assert.Throws <InvalidOperationException>(() => server.JvmCallbackClient);
using ISocketWrapper callbackSocket = SocketFactory.CreateSocket();
server.Run(callbackSocket);
Assert.NotNull(server.JvmCallbackClient);
}
private ISocketWrapper GetConnection()
{
if (!_sockets.TryDequeue(out ISocketWrapper socket))
{
socket = SocketFactory.CreateSocket();
socket.Connect(IPAddress.Loopback, _portNumber);
}
return(socket);
}
public void SocketFactory_WithNoSetting_ReturnsMySocket()
{
//arrange
ISocket socket;
SocketFactory factory = new SocketFactory();
//act
socket = factory.CreateSocket();
//assert
Assert.IsInstanceOfType(socket, typeof(MySocket));
}
public void TestInitialize()
{
sc = new SparkContext(null);
sc.StartAccumulatorServer();
// get accumulator server port and connect to accumuator server
int serverPort = (sc.SparkContextProxy as MockSparkContextProxy).AccumulatorServerPort;
sock = SocketFactory.CreateSocket();
sock.Connect(IPAddress.Loopback, serverPort, null);
}
/// <summary>
/// Runs the DaemonWorker server.
/// </summary>
internal void Run()
{
// TODO: Note that daemon server is stopped from Spark, it is done with
// Process.destroy(). It should send SIGTERM and the signal should be handled
// by the following:
// AppDomain.CurrentDomain.ProcessExit += (s, e) => {};,
// but the above handler is not invoked. This can be investigated if more
// graceful exit is required.
ISocketWrapper listener = SocketFactory.CreateSocket();
Run(listener);
}
/// <summary>
/// Returns row objects based on the function (either "toPythonIterator" or
/// "collectToPython").
/// </summary>
/// <param name="funcName"></param>
/// <returns></returns>
private IEnumerable <Row> GetRows(string funcName)
{
(int port, string secret) = GetConnectionInfo(funcName);
using (ISocketWrapper socket = SocketFactory.CreateSocket())
{
socket.Connect(IPAddress.Loopback, port, secret);
foreach (Row row in new RowCollector().Collect(socket))
{
yield return(row);
}
}
}
/// <summary>
/// Return an enumerable collection that contains all of the elements in this RDD.
/// </summary>
/// <remarks>
/// This method should only be used if the resulting array is expected to be small,
/// as all the data is loaded into the driver's memory.
/// </remarks>
/// <returns>An enumerable collection of all the elements.</returns>
public IEnumerable <T> Collect()
{
(int port, string secret) = CollectAndServe();
using ISocketWrapper socket = SocketFactory.CreateSocket();
socket.Connect(IPAddress.Loopback, port, secret);
var collector = new RDD.Collector();
System.IO.Stream stream = socket.InputStream;
foreach (T element in collector.Collect(stream, _serializedMode).Cast <T>())
{
yield return(element);
}
}
public void TestSaeaSocket()
{
// Set Socket wrapper to Saea
Environment.SetEnvironmentVariable(ConfigurationService.CSharpSocketTypeEnvName, "Saea");
SocketFactory.SocketWrapperType = SocketWrapperType.None;
var serverSocket = SocketFactory.CreateSocket();
Assert.IsTrue(serverSocket is SaeaSocketWrapper);
SocketTest(serverSocket);
// Reset socket wrapper type
Environment.SetEnvironmentVariable(ConfigurationService.CSharpSocketTypeEnvName, string.Empty);
SocketFactory.SocketWrapperType = SocketWrapperType.None;
}
public void SocketFactory_WithValidSetting_ReturnsSetSocket()
{
//arrange
ISocket mockSocket = new MockSocket();
SocketFactory factory = new SocketFactory();
factory.setSocket(mockSocket);
//act
ISocket resultSocket = factory.CreateSocket();
//assert
Assert.IsTrue(resultSocket == mockSocket);
//cleanup
factory.setSocket(null);
}
private ISocketWrapper GetConnection()
{
// Limit the number of connections to the JVM backend. Netty is configured
// to use a set number of threads to process incoming connections. Each
// new connection is delegated to these threads in a round robin fashion.
// A deadlock can occur on the JVM if a new connection is scheduled on a
// blocked thread.
_socketSemaphore.Wait();
if (!_sockets.TryDequeue(out ISocketWrapper socket))
{
socket = SocketFactory.CreateSocket();
socket.Connect(IPAddress.Loopback, _portNumber);
}
return(socket);
}
public string StartConnent()
{
if (_UDPServer == null)
{
SocketFactory factory = new SocketFactory();
_UDPServer = factory.CreateSocket(ServerType.UDP, HostName, Port);
string log = _UDPServer.Run();
if (log != null)
{
_UDPServer = null;
return(log);
}
_UDPServer.SocketEventHandler += new EventHandler(UDPEventHandler);
}
return(null);
}
public void TestsDaemonWorkerTaskRunners()
{
ISocketWrapper daemonSocket = SocketFactory.CreateSocket();
int taskRunnerNumber = 3;
var typedVersion = new Version(Versions.V2_4_0);
var daemonWorker = new DaemonWorker(typedVersion);
Task.Run(() => daemonWorker.Run(daemonSocket));
for (int i = 0; i < taskRunnerNumber; ++i)
{
CreateAndVerifyConnection(daemonSocket);
}
Assert.Equal(taskRunnerNumber, daemonWorker.CurrentNumTaskRunners);
}
private void TestCallbackConnection(
ConcurrentDictionary <int, ICallbackHandler> callbackHandlersDict,
ITestCallbackHandler callbackHandler,
int inputToHandler,
CancellationToken token)
{
using ISocketWrapper serverListener = SocketFactory.CreateSocket();
serverListener.Listen();
var ipEndpoint = (IPEndPoint)serverListener.LocalEndPoint;
using ISocketWrapper clientSocket = SocketFactory.CreateSocket();
clientSocket.Connect(ipEndpoint.Address, ipEndpoint.Port);
// Don't use "using" here. The CallbackConnection will dispose the socket.
ISocketWrapper serverSocket = serverListener.Accept();
var callbackConnection = new CallbackConnection(0, serverSocket, callbackHandlersDict);
Task task = Task.Run(() => callbackConnection.Run(token));
if (token.IsCancellationRequested)
{
task.Wait();
Assert.False(callbackConnection.IsRunning);
}
else
{
WriteAndReadTestData(clientSocket, callbackHandler, inputToHandler);
if (callbackHandler.Throws)
{
task.Wait();
Assert.False(callbackConnection.IsRunning);
}
else
{
Assert.True(callbackConnection.IsRunning);
// Clean up CallbackConnection
Stream outputStream = clientSocket.OutputStream;
SerDe.Write(outputStream, (int)CallbackConnection.ConnectionStatus.REQUEST_CLOSE);
outputStream.Flush();
task.Wait();
Assert.False(callbackConnection.IsRunning);
}
}
}
public IEnumerable <dynamic> Collect(SocketInfo info, SerializedMode serializedMode, Type type)
{
IFormatter formatter = new BinaryFormatter();
var sock = SocketFactory.CreateSocket();
sock.Connect(IPAddress.Loopback, info.Port, null);
using (var s = sock.GetStream())
{
if (info.Secret != null)
{
SerDe.Write(s, info.Secret);
var reply = SerDe.ReadString(s);
Logger.LogDebug("Connect back to JVM: " + reply);
}
byte[] buffer;
while ((buffer = SerDe.ReadBytes(s)) != null && buffer.Length > 0)
{
if (serializedMode == SerializedMode.Byte)
{
MemoryStream ms = new MemoryStream(buffer);
yield return(formatter.Deserialize(ms));
}
else if (serializedMode == SerializedMode.String)
{
yield return(Encoding.UTF8.GetString(buffer));
}
else if (serializedMode == SerializedMode.Pair)
{
MemoryStream ms = new MemoryStream(buffer);
MemoryStream ms2 = new MemoryStream(SerDe.ReadBytes(s));
ConstructorInfo ci = type.GetConstructors()[0];
yield return(ci.Invoke(new object[] { formatter.Deserialize(ms), formatter.Deserialize(ms2) }));
}
else if (serializedMode == SerializedMode.Row)
{
var unpickledObjects = PythonSerDe.GetUnpickledObjects(buffer);
foreach (var item in unpickledObjects)
{
yield return((item as RowConstructor).GetRow());
}
}
}
}
}
private ISocketWrapper CreateServer(out Process worker)
{
var tcpListener = SocketFactory.CreateSocket();
tcpListener.Listen();
int port = (tcpListener.LocalEndPoint as IPEndPoint).Port;
var exeLocation = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath) ?? ".";
worker = new Process
{
StartInfo =
{
FileName = Path.Combine(exeLocation, "CSharpWorker.exe"),
Arguments = "-m pyspark.worker",
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true
}
};
Environment.SetEnvironmentVariable("PYTHON_WORKER_FACTORY_PORT", port.ToString());
lock (syncLock)
{
output.Clear();
}
worker.OutputDataReceived += new DataReceivedEventHandler((sender, e) =>
{
if (!String.IsNullOrEmpty(e.Data))
{
Debug.WriteLine(e.Data);
lock (syncLock)
{
output.AppendLine(e.Data);
}
}
});
Console.WriteLine("Starting worker process from {0}", worker.StartInfo.FileName);
worker.Start();
worker.BeginOutputReadLine();
worker.StandardInput.WriteLine(port);
return(tcpListener);
}
public void TestsSimpleWorkerTaskRunners(string version)
{
using ISocketWrapper serverListener = SocketFactory.CreateSocket();
var ipEndpoint = (IPEndPoint)serverListener.LocalEndPoint;
serverListener.Listen();
var typedVersion = new Version(version);
var simpleWorker = new SimpleWorker(typedVersion);
Task clientTask = Task.Run(() => simpleWorker.Run(ipEndpoint.Port));
PayloadWriter payloadWriter = new PayloadWriterFactory().Create(typedVersion);
TaskRunnerTests.TestTaskRunnerReadWrite(serverListener, payloadWriter);
Assert.True(clientTask.Wait(5000));
}
public void TestsDaemonWorkerTaskRunners(string version)
{
ISocketWrapper daemonSocket = SocketFactory.CreateSocket();
int taskRunnerNumber = 2;
var typedVersion = new Version(version);
var daemonWorker = new DaemonWorker(typedVersion);
Task.Run(() => daemonWorker.Run(daemonSocket));
var clientSockets = new List <ISocketWrapper>();
for (int i = 0; i < taskRunnerNumber; ++i)
{
CreateAndVerifyConnection(daemonSocket, clientSockets, typedVersion);
}
Assert.Equal(taskRunnerNumber, daemonWorker.CurrentNumTaskRunners);
}
public void TestRioSocket()
{
if (!SocketFactory.IsRioSockSupported())
{
Assert.Ignore("Omitting due to missing Riosock.dll. It might caused by no VC++ build tool or running on an OS that not supports Windows RIO socket.");
}
// Set Socket wrapper to Rio
Environment.SetEnvironmentVariable(ConfigurationService.CSharpSocketTypeEnvName, "Rio");
SocketFactory.SocketWrapperType = SocketWrapperType.None;
RioSocketWrapper.rioRqGrowthFactor = 1;
var serverSocket = SocketFactory.CreateSocket();
Assert.IsTrue(serverSocket is RioSocketWrapper);
SocketTest(serverSocket);
// Reset socket wrapper type
Environment.SetEnvironmentVariable(ConfigurationService.CSharpSocketTypeEnvName, string.Empty);
SocketFactory.SocketWrapperType = SocketWrapperType.None;
RioNative.UnloadRio();
}
private void TestCallbackConnection(
ConcurrentDictionary <int, ICallbackHandler> callbackHandlersDict,
ITestCallbackHandler callbackHandler,
int inputToHandler,
CancellationToken token)
{
using ISocketWrapper serverListener = SocketFactory.CreateSocket();
serverListener.Listen();
var ipEndpoint = (IPEndPoint)serverListener.LocalEndPoint;
ISocketWrapper clientSocket = SocketFactory.CreateSocket();
clientSocket.Connect(ipEndpoint.Address, ipEndpoint.Port);
var callbackConnection = new CallbackConnection(0, clientSocket, callbackHandlersDict);
Task.Run(() => callbackConnection.Run(token));
using ISocketWrapper serverSocket = serverListener.Accept();
WriteAndReadTestData(serverSocket, callbackHandler, inputToHandler, token);
}
private int StartCallbackServer()
{
var callbackServer = SocketFactory.CreateSocket();
callbackServer.Listen();
Task.Run(() =>
{
try
{
ThreadPool.SetMaxThreads(10, 10);
while (!callbackSocketShutdown)
{
var sock = callbackServer.Accept();
ThreadPool.QueueUserWorkItem(ProcessCallbackRequest, sock);
}
}
catch (Exception e)
{
logger.LogError("Exception starting callback server");
logger.LogException(e);
throw;
}
finally
{
if (callbackServer != null)
{
callbackServer.Close();
}
}
});
int port = (callbackServer.LocalEndPoint as IPEndPoint).Port;
logger.LogInfo("Callback server port number is {0}", port);
SparkCLRIpcProxy.JvmBridge.CallStaticJavaMethod("SparkCLRHandler", "connectCallback", port); //className and methodName hard coded in CSharpBackendHandler
return(port);
}
public bool StartConnent()
{
if (socketClient == null)
{
SocketFactory factory = new SocketFactory();
string localIp = Properties.Settings.Default.LocalIP;
int localPort = Properties.Settings.Default.LocalPort;
socketClient = factory.CreateSocket(ServerType.TCPClient, localIp, localPort);
string log = socketClient.Run();
if (log != null)
{
socketClient = null;
DXMessageBox.Show("连接服务器失败/n" + log, "提示", MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
socketClient.SocketEventHandler += new EventHandler(SocketEventHandler);
ExcuteTimerCust_Tick(this, null);
ExcuteTimerCust.Start();
}
return(true);
}
/// <exception cref="NSch.JSchException"></exception>
public virtual void Connect(SocketFactory socket_factory, string host, int port,
int timeout)
{
try
{
if (socket_factory == null)
{
socket = Util.CreateSocket(proxy_host, proxy_port, timeout);
//socket=new Socket(proxy_host, proxy_port);
@in = socket.GetInputStream();
@out = socket.GetOutputStream();
}
else
{
socket = socket_factory.CreateSocket(proxy_host, proxy_port);
@in = socket_factory.GetInputStream(socket);
@out = socket_factory.GetOutputStream(socket);
}
if (timeout > 0)
{
socket.ReceiveTimeout = timeout;
}
socket.NoDelay = true;
byte[] buf = new byte[1024];
int index = 0;
buf[index++] = 5;
buf[index++] = 2;
buf[index++] = 0;
// NO AUTHENTICATION REQUIRED
buf[index++] = 2;
// USERNAME/PASSWORD
@out.Write(buf, 0, index);
//in.read(buf, 0, 2);
Fill(@in, buf, 2);
bool check = false;
switch ((buf[1]) & unchecked((int)(0xff)))
{
case 0:
{
// NO AUTHENTICATION REQUIRED
check = true;
break;
}
case 2:
{
// USERNAME/PASSWORD
if (user == null || passwd == null)
{
break;
}
index = 0;
buf[index++] = 1;
buf[index++] = unchecked((byte)(user.Length));
System.Array.Copy(Util.Str2byte(user), 0, buf, index, user.Length);
index += user.Length;
buf[index++] = unchecked((byte)(passwd.Length));
System.Array.Copy(Util.Str2byte(passwd), 0, buf, index, passwd.Length);
index += passwd.Length;
@out.Write(buf, 0, index);
//in.read(buf, 0, 2);
Fill(@in, buf, 2);
if (buf[1] == 0)
{
check = true;
}
break;
}
default:
{
break;
}
}
if (!check)
{
try
{
socket.Close();
}
catch (Exception)
{
}
throw new JSchException("fail in SOCKS5 proxy");
}
index = 0;
buf[index++] = 5;
buf[index++] = 1;
// CONNECT
buf[index++] = 0;
byte[] hostb = Util.Str2byte(host);
int len = hostb.Length;
buf[index++] = 3;
// DOMAINNAME
buf[index++] = unchecked((byte)(len));
System.Array.Copy(hostb, 0, buf, index, len);
index += len;
buf[index++] = unchecked((byte)((int)(((uint)port) >> 8)));
buf[index++] = unchecked((byte)(port & unchecked((int)(0xff))));
@out.Write(buf, 0, index);
//in.read(buf, 0, 4);
Fill(@in, buf, 4);
if (buf[1] != 0)
{
try
{
socket.Close();
}
catch (Exception)
{
}
throw new JSchException("ProxySOCKS5: server returns " + buf[1]);
}
switch (buf[3] & unchecked((int)(0xff)))
{
case 1:
{
//in.read(buf, 0, 6);
Fill(@in, buf, 6);
break;
}
case 3:
{
//in.read(buf, 0, 1);
Fill(@in, buf, 1);
//in.read(buf, 0, buf[0]+2);
Fill(@in, buf, (buf[0] & unchecked((int)(0xff))) + 2);
break;
}
case 4:
{
//in.read(buf, 0, 18);
Fill(@in, buf, 18);
break;
}
default:
{
break;
}
}
}
catch (RuntimeException e)
{
throw;
}
catch (Exception e)
{
try
{
if (socket != null)
{
socket.Close();
}
}
catch (Exception)
{
}
string message = "ProxySOCKS5: " + e.ToString();
if (e is Exception)
{
throw new JSchException(message, (Exception)e);
}
throw new JSchException(message);
}
}
/// <exception cref="NSch.JSchException"></exception>
public virtual void Connect(SocketFactory socket_factory, string host, int port,
int timeout)
{
try
{
if (socket_factory == null)
{
socket = Util.CreateSocket(proxy_host, proxy_port, timeout);
@in = socket.GetInputStream();
@out = socket.GetOutputStream();
}
else
{
socket = socket_factory.CreateSocket(proxy_host, proxy_port);
@in = socket_factory.GetInputStream(socket);
@out = socket_factory.GetOutputStream(socket);
}
if (timeout > 0)
{
socket.ReceiveTimeout = timeout;
}
socket.NoDelay = true;
@out.Write(Util.Str2byte("CONNECT " + host + ":" + port + " HTTP/1.0\r\n"));
if (user != null && passwd != null)
{
byte[] code = Util.Str2byte(user + ":" + passwd);
code = Util.ToBase64(code, 0, code.Length);
@out.Write(Util.Str2byte("Proxy-Authorization: Basic "));
@out.Write(code);
@out.Write(Util.Str2byte("\r\n"));
}
@out.Write(Util.Str2byte("\r\n"));
@out.Flush();
int foo = 0;
StringBuilder sb = new StringBuilder();
while (foo >= 0)
{
foo = @in.Read();
if (foo != 13)
{
sb.Append((char)foo);
continue;
}
foo = @in.Read();
if (foo != 10)
{
continue;
}
break;
}
if (foo < 0)
{
throw new IOException();
}
string response = sb.ToString();
string reason = "Unknow reason";
int code_1 = -1;
try
{
foo = response.IndexOf(' ');
int bar = response.IndexOf(' ', foo + 1);
code_1 = System.Convert.ToInt32(Sharpen.Runtime.Substring(response, foo + 1, bar)
);
reason = Sharpen.Runtime.Substring(response, bar + 1);
}
catch (Exception)
{
}
if (code_1 != 200)
{
throw new IOException("proxy error: " + reason);
}
int count = 0;
while (true)
{
count = 0;
while (foo >= 0)
{
foo = @in.Read();
if (foo != 13)
{
count++;
continue;
}
foo = @in.Read();
if (foo != 10)
{
continue;
}
break;
}
if (foo < 0)
{
throw new IOException();
}
if (count == 0)
{
break;
}
}
}
catch (RuntimeException e)
{
throw;
}
catch (Exception e)
{
try
{
if (socket != null)
{
socket.Close();
}
}
catch (Exception)
{
}
string message = "ProxyHTTP: " + e.ToString();
if (e is Exception)
{
throw new JSchException(message, (Exception)e);
}
throw new JSchException(message);
}
}
/// <exception cref="NSch.JSchException"></exception>
public virtual void Connect(SocketFactory socket_factory, string host, int port,
int timeout)
{
try
{
if (socket_factory == null)
{
socket = Util.CreateSocket(proxy_host, proxy_port, timeout);
//socket=new Socket(proxy_host, proxy_port);
@in = socket.GetInputStream();
@out = socket.GetOutputStream();
}
else
{
socket = socket_factory.CreateSocket(proxy_host, proxy_port);
@in = socket_factory.GetInputStream(socket);
@out = socket_factory.GetOutputStream(socket);
}
if (timeout > 0)
{
socket.ReceiveTimeout = timeout;
}
socket.NoDelay = true;
byte[] buf = new byte[1024];
int index = 0;
index = 0;
buf[index++] = 4;
buf[index++] = 1;
buf[index++] = unchecked((byte)((int)(((uint)port) >> 8)));
buf[index++] = unchecked((byte)(port & unchecked((int)(0xff))));
try
{
IPAddress addr = Sharpen.Extensions.GetAddressByName(host);
byte[] byteAddress = addr.GetAddressBytes();
for (int i = 0; i < byteAddress.Length; i++)
{
buf[index++] = byteAddress[i];
}
}
catch (UnknownHostException uhe)
{
throw new JSchException("ProxySOCKS4: " + uhe.ToString(), uhe);
}
if (user != null)
{
System.Array.Copy(Util.Str2byte(user), 0, buf, index, user.Length);
index += user.Length;
}
buf[index++] = 0;
@out.Write(buf, 0, index);
int len = 8;
int s = 0;
while (s < len)
{
int i = @in.Read(buf, s, len - s);
if (i <= 0)
{
throw new JSchException("ProxySOCKS4: stream is closed");
}
s += i;
}
if (buf[0] != 0)
{
throw new JSchException("ProxySOCKS4: server returns VN " + buf[0]);
}
if (buf[1] != 90)
{
try
{
socket.Close();
}
catch (Exception)
{
}
string message = "ProxySOCKS4: server returns CD " + buf[1];
throw new JSchException(message);
}
}
catch (RuntimeException e)
{
throw;
}
catch (Exception e)
{
try
{
if (socket != null)
{
socket.Close();
}
}
catch (Exception)
{
}
throw new JSchException("ProxySOCKS4: " + e.ToString());
}
}