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