Esempio n. 1
0
        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;
            }
        }
Esempio n. 2
0
        /// <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 {
                _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(Address, port);
                } else {
                    _TcpClient.Connect(Address, port);
                }

                Stream stream = _TcpClient.GetStream();
                if (_UseSsl) {
                    RemoteCertificateValidationCallback certValidation;
                    if (_ValidateServerCertificate) {
                        certValidation = ServicePointManager.ServerCertificateValidationCallback;
                        if (certValidation == null) {
                            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; };
                    }
                    RemoteCertificateValidationCallback certValidationWithIrcAsSender =
                        delegate(object sender, X509Certificate certificate,
                                 X509Chain chain, SslPolicyErrors sslPolicyErrors) {
                        return certValidation(this, certificate, chain, sslPolicyErrors);
                    };
                    LocalCertificateSelectionCallback selectionCallback = delegate(object sender, string targetHost, X509CertificateCollection localCertificates, X509Certificate remoteCertificate, string[] acceptableIssuers) {
                        if (localCertificates == null || localCertificates.Count == 0) {
                            return null;
                        }
                        return localCertificates[0];
                    };
                    SslStream sslStream = new SslStream(stream, false,
                                                        certValidationWithIrcAsSender,
                                                        selectionCallback);
                    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;
                }
                if (EnableUTF8Recode) {
                    _Reader = new StreamReader(stream, new PrimaryOrFallbackEncoding(new UTF8Encoding(false, true), _Encoding));
                    _Writer = new StreamWriter(stream, new UTF8Encoding(false, false));
                } else {
                    _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);
                }
            }
        }
Esempio n. 3
0
        // 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;
        }
        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;
        }
Esempio n. 5
0
        /// <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);
        }
Esempio n. 6
0
        void ApplyConfig(UserConfig config, XmppServerModel server)
        {
            if (String.IsNullOrEmpty(server.Nickname)) {
                Nicknames = (string[]) config["Connection/Nicknames"];
            } else {
                Nicknames = new string[] { server.Nickname };
            }

            if (server.Username.Contains("@")) {
                var jid_user = server.Username.Split('@')[0];
                var jid_host = server.Username.Split('@')[1];
                JabberClient.ConnectServer = server.Hostname;
                JabberClient.AutoResolveConnectServer = false;
                JabberClient.Username = jid_user;
                JabberClient.Server = jid_host;
            } else {
                JabberClient.Server = server.Hostname;
                JabberClient.Username = server.Username;
            }
            JabberClient.Port = server.Port;
            JabberClient.Password = server.Password;

            var proxySettings = new ProxySettings();
            proxySettings.ApplyConfig(config);
            var protocol = Server.UseEncryption ? "xmpps" : "xmpp";
            var serverUri = String.Format("{0}://{1}:{2}", protocol,
                                          Server.Hostname, Server.Port);
            var proxy = proxySettings.GetWebProxy(serverUri);
            var socket = JabberClient.ClientSocket as ClientSocket;
            if (proxy == null) {
                socket.Proxy = null;
            } else {
                var builder = CreateMessageBuilder();
                builder.AppendEventPrefix();
                builder.AppendText(_("Using proxy: {0}:{1}"),
                                   proxy.Address.Host,
                                   proxy.Address.Port);
                Session.AddMessageToChat(Chat, builder.ToMessage());

                var proxyScheme = proxy.Address.Scheme;
                var proxyType = Starksoft.Net.Proxy.ProxyType.None;
                try {
                    proxyType = (Starksoft.Net.Proxy.ProxyType) Enum.Parse(
                        typeof(Starksoft.Net.Proxy.ProxyType),
                        proxy.Address.Scheme,
                        true
                    );
                } catch (ArgumentException ex) {
            #if LOG4NET
                    _Logger.Error("ApplyConfig(): Couldn't parse proxy type: " +
                                  proxyScheme, ex);
            #endif
                }

                var proxyFactory = new ProxyClientFactory();
                if (String.IsNullOrEmpty(proxySettings.ProxyUsername) &&
                    String.IsNullOrEmpty(proxySettings.ProxyPassword)) {
                    socket.Proxy = proxyFactory.CreateProxyClient(
                        proxyType,
                        proxy.Address.Host,
                        proxy.Address.Port
                    );
                } else {
                    socket.Proxy = proxyFactory.CreateProxyClient(
                        proxyType,
                        proxy.Address.Host,
                        proxy.Address.Port,
                        proxySettings.ProxyUsername,
                        proxySettings.ProxyPassword
                    );
                }
            }

            Me = new PersonModel(
                JabberClient.MyJID.Bare,
                Nicknames[0],
                NetworkID, Protocol, this
            );
            Me.IdentityNameColored.ForegroundColor = new TextColor(0, 0, 255);
            Me.IdentityNameColored.BackgroundColor = TextColor.None;
            Me.IdentityNameColored.Bold = true;

            // XMPP specific settings
            JabberClient.Resource = server.Resource;

            if (server.UseEncryption) {
                // HACK: Google Talk doesn't support StartTLS :(
                if (server.Hostname == "talk.google.com" &&
                    server.Port == 5223) {
                    JabberClient.ForceStartTls = false;
                    JabberClient.UseSSL = true;
                } else {
                    JabberClient.ForceStartTls = true;
                }
            } else {
                JabberClient.ForceStartTls = false;
                JabberClient.UseStartTLS = true;
            }
            if (!server.ValidateServerCertificate) {
                JabberClient.ClientSocket.OnValidateCertificate += ValidateCertificate;
            }
        }
            /// <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);
            }