// Proxy for FTP public IProxyClient GetProxyClient() { if (IsValidProxy()) { Starksoft.Net.Proxy.ProxyType proxyType; switch (ProxyType) { case ProxyType.HTTP: proxyType = Starksoft.Net.Proxy.ProxyType.Http; break; case ProxyType.SOCKS4: proxyType = Starksoft.Net.Proxy.ProxyType.Socks4; break; case ProxyType.SOCKS4a: proxyType = Starksoft.Net.Proxy.ProxyType.Socks4a; break; case ProxyType.SOCKS5: proxyType = Starksoft.Net.Proxy.ProxyType.Socks5; break; default: proxyType = Starksoft.Net.Proxy.ProxyType.None; break; } ProxyClientFactory proxy = new ProxyClientFactory(); return(proxy.CreateProxyClient(proxyType, Host, Port, Username, Password)); } return(null); }
private static (Collection <FunctionMetadata>, ProxyClientExecutor) LoadProxyMetadata(string proxiesJson, Dictionary <string, ICollection <string> > functionErrors, ILogger logger) { var proxies = new Collection <FunctionMetadata>(); ProxyClientExecutor client = null; var rawProxyClient = ProxyClientFactory.Create(proxiesJson, logger); if (rawProxyClient != null) { client = new ProxyClientExecutor(rawProxyClient); } if (client == null) { return(proxies, null); } var routes = client.GetProxyData(); foreach (var route in routes.Routes) { try { // Proxy names should follow the same naming restrictions as in function names. If not, invalid characters will be removed. var proxyName = NormalizeProxyName(route.Name); var proxyMetadata = new FunctionMetadata(); var json = new JObject { { "authLevel", "anonymous" }, { "name", "req" }, { "type", "httptrigger" }, { "direction", "in" }, { "Route", route.UrlTemplate.TrimStart('/') }, { "Methods", new JArray(route.Methods.Select(m => m.Method.ToString()).ToArray()) } }; BindingMetadata bindingMetadata = BindingMetadata.Create(json); proxyMetadata.Bindings.Add(bindingMetadata); proxyMetadata.Name = proxyName; proxyMetadata.IsProxy = true; proxies.Add(proxyMetadata); } catch (Exception ex) { // log any unhandled exceptions and continue Utility.AddFunctionError(functionErrors, route.Name, Utility.FlattenException(ex, includeSource: false), isFunctionShortName: true); } } return(proxies, client); }
/// <summary> /// Creates the proxy from the values within this object. /// </summary> /// <returns> /// The proxy. /// </returns> public IProxyClient CreateProxy() { var pcf = new ProxyClientFactory(); if (string.IsNullOrWhiteSpace(UserName)) { return(pcf.CreateProxyClient(Type, Host, Port)); } return(pcf.CreateProxyClient(Type, Host, Port, UserName, Password ?? string.Empty)); }
internal proxy(string target_host, int target_port, string proxy_host, int proxy_port, ProxyType type) { Console.WriteLine("Socket allocated."); this.proxy_conn = new proxy.conn(); this.proxy_conn.proxy_config(target_host, target_port, proxy_host, proxy_port, type); ProxyClientFactory factory = new ProxyClientFactory(); this.proxy_conn.Proxy = factory.CreateProxyClient(type, proxy_host, proxy_port); this.proxy_conn.Proxy.CreateConnectionAsyncCompleted += new EventHandler <CreateConnectionAsyncCompletedEventArgs>(proxy_connected); //this.Proxy.CreateConnectionAsync(obj.target_host, obj.target_port); }
/// <summary> /// /// </summary> /// <param name="targetHost"></param> /// <param name="targetPort"></param> /// <returns></returns> TcpClient ConnectViaHTTPProxy( ) { // create an instance of the client proxy factory ProxyClientFactory factory = new ProxyClientFactory(); // use the proxy client factory to generically specify the type of proxy to create // the proxy factory method CreateProxyClient returns an IProxyClient object IProxyClient proxy = factory.CreateProxyClient(ProxyType.Http, ProxyInfo.Host, ProxyInfo.Port, ProxyInfo.UserName, ProxyInfo.Password); // create a connection through the proxy to www.starksoft.com over port 80 return(proxy.CreateConnection(Host, Port)); }
public TorProxy(string target_host, int target_port, string proxy_host, int proxy_port, ProxyType type) { if (InputProxyMessage != null) { InputProxyMessage.Invoke("Socket allocated."); } proxy_connection = new connection(); proxy_connection.proxy_config(target_host, target_port, proxy_host, proxy_port, type); ProxyClientFactory factory = new ProxyClientFactory(); proxy_connection.Proxy = factory.CreateProxyClient(type, proxy_host, proxy_port); proxy_connection.Proxy.CreateConnectionAsyncCompleted += new EventHandler <CreateConnectionAsyncCompletedEventArgs>(proxy_connected); }
/// <summary> /// /// </summary> /// <param name="destinationHost">Host destino que requiere proxy</param> /// <param name="destinationPort">Puerto destino</param> /// <returns></returns> TcpClient ConnectViaHTTPProxy(string destinationHost, int destinationPort) { // create an instance of the client proxy factory ProxyClientFactory factory = new ProxyClientFactory(); // use the proxy client factory to generically specify the type of proxy to create // the proxy factory method CreateProxyClient returns an IProxyClient object //IProxyClient proxy = factory.CreateProxyClient(ProxyType.Http, MailProcessor.ProxyInfo.Host, MailProcessor.ProxyInfo.Port, MailProcessor.ProxyInfo.UserName, MailProcessor.ProxyInfo.Password); IProxyClient proxy = factory.CreateProxyClient(ProxyType.Http, this._Proxy.Host, this._Proxy.Port, this._Proxy.UserName, this._Proxy.Password); // create a connection through the proxy to www.starksoft.com over port 80 return(proxy.CreateConnection(destinationHost, destinationPort)); }
public void Connect(string command, params object[] arguments) { Uri uri = new Uri(command); _connectArguments = arguments; int port = uri.Port <= 0 ? 1935 : uri.Port; //_connectionParameters["tcUrl"] = "rtmp://" + uri.Host + (uri.Port > 0 ? uri.Port.ToString() + ':' : string.Empty) + uri.PathAndQuery; _connectionParameters["tcUrl"] = command; string app = uri.LocalPath.TrimStart(new char[] { '/' }); _connectionParameters["app"] = app; Socket socket = null; // Support for proxies in non-Silverlight apps. #if !SILVERLIGHT if (Proxy != null) { ProxyClientFactory factory = new ProxyClientFactory(); string[] proxyParts = _proxy.Server.Split(':'); IProxyClient proxyClient = factory.CreateProxyClient(_proxy.TypeToInternalType(), proxyParts[0], int.Parse(proxyParts[1])); Uri endpoint = new Uri(command); TcpClient tcpClient = proxyClient.CreateConnection(endpoint.Host, endpoint.Port); socket = tcpClient.Client; } else { socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); socket.Connect(uri.Host, port); } #else socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); #endif #if !SILVERLIGHT _connection = new RtmpClientConnection(this, socket, _secure, uri.Host); _connection.Context.ObjectEncoding = _netConnection.ObjectEncoding; _connection.BeginHandshake(); #else DnsEndPoint endPoint = new DnsEndPoint(uri.Host, port); SocketAsyncEventArgs args = new SocketAsyncEventArgs(); args.UserToken = socket; args.RemoteEndPoint = endPoint; args.Completed += new EventHandler <SocketAsyncEventArgs>(OnSocketConnectCompleted); socket.ConnectAsync(args); #endif }
TcpClient CreateConnectedTcpClient(ServiceEndPoint endPoint) { TcpClient client; if (endPoint.Proxy == null) { client = CreateTcpClient(); client.ConnectWithTimeout(endPoint.BaseUri, HalibutLimits.TcpClientConnectTimeout); } else { log.Write(EventType.Diagnostic, "Creating a proxy client"); client = new ProxyClientFactory() .CreateProxyClient(log, endPoint.Proxy) .WithTcpClientFactory(CreateTcpClient) .CreateConnection(endPoint.BaseUri.Host, endPoint.BaseUri.Port, HalibutLimits.TcpClientConnectTimeout); } return(client); }
internal static TcpClient CreateConnectedTcpClient(ServiceEndPoint endPoint, ILog log, CancellationToken cancellationToken) { TcpClient client; if (endPoint.Proxy == null) { client = CreateTcpClient(); client.ConnectWithTimeout(endPoint.BaseUri, endPoint.TcpClientConnectTimeout, cancellationToken); } else { log.Write(EventType.Diagnostic, "Creating a proxy client"); client = new ProxyClientFactory() .CreateProxyClient(log, endPoint.Proxy) .WithTcpClientFactory(CreateTcpClient) .CreateConnection(endPoint.BaseUri.Host, endPoint.BaseUri.Port, endPoint.TcpClientConnectTimeout, cancellationToken); } return(client); }
private TcpClient getProxyClient() { if (ProxyPort == 0) { string[] proxyip = bots.getSocks().Split(':'); if (proxyip.Length == 2) { ProxyIP = proxyip[0]; ProxyPort = int.Parse(proxyip[1]); } else { ProxyIP = proxyip[0]; ProxyPort = 8080; } } ProxyClientFactory factory = new ProxyClientFactory(); IProxyClient proxy = factory.CreateProxyClient(ProxyType.Http, ProxyIP, ProxyPort); return(proxy.CreateConnection(Host, Port)); }
static IProxyClient MakeProxy(Uri proxyUri) { // Uses https://github.com/grinay/ProxyLib ProxyClientFactory factory = new ProxyClientFactory(); if (proxyUri.UserInfo == string.Empty) { return(factory.CreateProxyClient(ProxyType.Http, proxyUri.Host, proxyUri.Port)); } else { if (proxyUri.UserInfo.Contains(':')) { var userPass = proxyUri.UserInfo.Split(':'); return(factory.CreateProxyClient(ProxyType.Http, proxyUri.Host, proxyUri.Port, userPass[0], userPass[1])); } else { throw new Exception($"Invalid user info: {proxyUri.UserInfo}"); } } }
public TorInstance(string _torloc, int _controlPort, int _socksPort, bool useExistingTorPorts = false) { // Assign member variables // state = TorState.Bootstrapping; torloc = _torloc; controlPort = (ushort)_controlPort; socksPort = (ushort)_socksPort; dataDirectory = string.Format("./data/{0}", this.GetHashCode()); System.Console.WriteLine("TorInstance({0:d}) created. Socks: {1:d}", this.GetHashCode(), socksPort); factory = new ProxyClientFactory(); proxy = factory.CreateProxyClient(ProxyType.Socks5, "127.0.0.1", socksPort); if (!useExistingTorPorts) { StartTorThread(); } else { state = TorState.Ready; } }
public IProxyClient GetProxyClient(ProxyInfo myProxyInfo) { if (myProxyInfo != null) { ProxyType proxyType; switch (myProxyInfo.ProxyType) { case Proxy.HTTP: proxyType = ProxyType.Http; break; case Proxy.SOCKS4: proxyType = ProxyType.Socks4; break; case Proxy.SOCKS4a: proxyType = ProxyType.Socks4a; break; case Proxy.SOCKS5: proxyType = ProxyType.Socks5; break; default: proxyType = ProxyType.None; break; } ProxyClientFactory proxy = new ProxyClientFactory(); return(proxy.CreateProxyClient(proxyType, myProxyInfo.Host, myProxyInfo.Port, myProxyInfo.UserName, myProxyInfo.Password)); } return(null); }
/// <overloads>this method has 2 overloads</overloads> /// <summary> /// Connects to the specified server and port, when the connection fails /// the next server in the list will be used. /// </summary> /// <param name="addresslist">List of servers to connect to</param> /// <param name="port">Portnumber to connect to</param> /// <exception cref="CouldNotConnectException">The connection failed</exception> /// <exception cref="AlreadyConnectedException">If there is already an active connection</exception> public void Connect(string[] addresslist, int port) { if (_IsConnected) { throw new AlreadyConnectedException("Already connected to: " + Address + ":" + Port); } _AutoRetryAttempt++; #if LOG4NET Logger.Connection.Info(String.Format("connecting... (attempt: {0})", _AutoRetryAttempt)); #endif _AddressList = (string[])addresslist.Clone(); _Port = port; if (OnConnecting != null) { OnConnecting(this, EventArgs.Empty); } try { System.Net.IPAddress ip = System.Net.Dns.Resolve(Address).AddressList[0]; _TcpClient = new TcpClient(); _TcpClient.NoDelay = true; _TcpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1); // set timeout, after this the connection will be aborted _TcpClient.ReceiveTimeout = _SocketReceiveTimeout * 1000; _TcpClient.SendTimeout = _SocketSendTimeout * 1000; if (_ProxyType != ProxyType.None) { IProxyClient proxyClient = null; ProxyClientFactory proxyFactory = new ProxyClientFactory(); // HACK: map our ProxyType to Starksoft's ProxyType Starksoft.Net.Proxy.ProxyType proxyType = (Starksoft.Net.Proxy.ProxyType)Enum.Parse( typeof(ProxyType), _ProxyType.ToString(), true ); if (_ProxyUsername == null && _ProxyPassword == null) { proxyClient = proxyFactory.CreateProxyClient( proxyType ); } else { proxyClient = proxyFactory.CreateProxyClient( proxyType, _ProxyHost, _ProxyPort, _ProxyUsername, _ProxyPassword ); } _TcpClient.Connect(_ProxyHost, _ProxyPort); proxyClient.TcpClient = _TcpClient; proxyClient.CreateConnection(ip.ToString(), port); } else { _TcpClient.Connect(ip, port); } Stream stream = _TcpClient.GetStream(); if (_UseSsl) { RemoteCertificateValidationCallback certValidation; if (_ValidateServerCertificate) { certValidation = delegate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { if (sslPolicyErrors == SslPolicyErrors.None) { return(true); } #if LOG4NET Logger.Connection.Error( "Connect(): Certificate error: " + sslPolicyErrors ); #endif return(false); }; } else { certValidation = delegate { return(true); }; } SslStream sslStream = new SslStream(stream, false, certValidation); try { if (_SslClientCertificate != null) { var certs = new X509Certificate2Collection(); certs.Add(_SslClientCertificate); sslStream.AuthenticateAsClient(Address, certs, SslProtocols.Default, false); } else { sslStream.AuthenticateAsClient(Address); } } catch (IOException ex) { #if LOG4NET Logger.Connection.Error( "Connect(): AuthenticateAsClient() failed!" ); #endif throw new CouldNotConnectException("Could not connect to: " + Address + ":" + Port + " " + ex.Message, ex); } stream = sslStream; } _Reader = new StreamReader(stream, _Encoding); _Writer = new StreamWriter(stream, _Encoding); if (_Encoding.GetPreamble().Length > 0) { // HACK: we have an encoding that has some kind of preamble // like UTF-8 has a BOM, this will confuse the IRCd! // Thus we send a \r\n so the IRCd can safely ignore that // garbage. _Writer.WriteLine(); // make sure we flush the BOM+CRLF correctly _Writer.Flush(); } // Connection was succeful, reseting the connect counter _AutoRetryAttempt = 0; // updating the connection error state, so connecting is possible again IsConnectionError = false; _IsConnected = true; // lets power up our threads _ReadThread.Start(); _WriteThread.Start(); _IdleWorkerThread.Start(); #if LOG4NET Logger.Connection.Info("connected"); #endif if (OnConnected != null) { OnConnected(this, EventArgs.Empty); } } catch (AuthenticationException ex) { #if LOG4NET Logger.Connection.Error("Connect(): Exception", ex); #endif throw new CouldNotConnectException("Could not connect to: " + Address + ":" + Port + " " + ex.Message, ex); } catch (Exception e) { if (_Reader != null) { try { _Reader.Close(); } catch (ObjectDisposedException) { } } if (_Writer != null) { try { _Writer.Close(); } catch (ObjectDisposedException) { } } if (_TcpClient != null) { _TcpClient.Close(); } _IsConnected = false; IsConnectionError = true; #if LOG4NET Logger.Connection.Info("connection failed: " + e.Message, e); #endif if (e is CouldNotConnectException) { // error was fatal, bail out throw; } if (_AutoRetry && (_AutoRetryLimit == -1 || _AutoRetryLimit == 0 || _AutoRetryLimit <= _AutoRetryAttempt)) { if (OnAutoConnectError != null) { OnAutoConnectError(this, new AutoConnectErrorEventArgs(Address, Port, e)); } #if LOG4NET Logger.Connection.Debug("delaying new connect attempt for " + _AutoRetryDelay + " sec"); #endif Thread.Sleep(_AutoRetryDelay * 1000); _NextAddress(); // FIXME: this is recursion Connect(_AddressList, _Port); } else { throw new CouldNotConnectException("Could not connect to: " + Address + ":" + Port + " " + e.Message, e); } } }