예제 #1
0
        public SocketConnector AddConnector(string name, IPEndPoint remoteEndPoint, ProxyInfo proxyData, EncryptType encryptType, CompressionType compressionType, ICryptoService cryptoService, int reconnectAttempts, int reconnectAttemptInterval, IPEndPoint localEndPoint)
        {
            SocketConnector result = null;

            if (!Disposed)
            {
                result = new SocketConnector(this, name, remoteEndPoint, proxyData, encryptType, compressionType, cryptoService, reconnectAttempts, reconnectAttemptInterval, localEndPoint);
                result.AddCreator();
            }

            return result;
        }
예제 #2
0
        public SocketConnector(BaseSocketConnectionHost host, string name, IPEndPoint remoteEndPoint, ProxyInfo proxyData, EncryptType encryptType, CompressionType compressionType, ICryptoService cryptoService, int reconnectAttempts, int reconnectAttemptInterval, IPEndPoint localEndPoint)
            : base(host, name, localEndPoint, encryptType, compressionType, cryptoService, remoteEndPoint)
        {
            FReconnectTimer = new Timer(new TimerCallback(ReconnectConnectionTimerCallBack));

            FReconnectAttempts = reconnectAttempts;
            FReconnectAttemptInterval = reconnectAttemptInterval;

            FReconnectAttempted = 0;

            FProxyInfo = proxyData;
        }
예제 #3
0
        public override void Free(bool canAccessFinalizable)
        {
            if (FReconnectTimer != null)
            {
                FReconnectTimer.Dispose();
                FReconnectTimer = null;
            }

            if (FSocket != null)
            {
                FSocket.Close();
                FSocket = null;
            }

            FProxyInfo = null;

            base.Free(canAccessFinalizable);
        }
예제 #4
0
        public SocketClientSync(IPEndPoint host)
        {
            FReceivedEvent = new AutoResetEvent(false);
            FExceptionEvent = new AutoResetEvent(false);
            FSentEvent = new AutoResetEvent(false);
            FConnectEvent = new AutoResetEvent(false);
            FDisconnectEvent = new ManualResetEvent(false);

            FReceivedQueue = new Queue<string>();

            FConnectTimeout = 10000;
            FSentTimeout = 10000;

            FConnectedSync = new object();
            FConnected = false;

            FSocketClientEvents = new SocketClientSyncSocketService(this);
            FCryptClientEvents = new SocketClientSyncCryptService(this);

            FLocalEndPoint = null;
            FRemoteEndPoint = host;

            //----- Message Types!
            FEncryptType = EncryptType.etNone;
            FCompressionType = CompressionType.ctNone;
            FDelimiterType = DelimiterType.dtNone;

            //----- Proxy!
            FProxyInfo = null;

            //----- Socket delimiter and buffer size!
            FDelimiter = null;

            FMessageBufferSize = 4096;
            FSocketBufferSize = 2048;
        }
예제 #5
0
        internal static void GetProxyResponseStatus(ProxyInfo proxyInfo, byte[] response)
        {
            switch (proxyInfo.ProxyType)
            {
                case ProxyType.ptHTTP:

                    Match m = Regex.Match(Encoding.GetEncoding(1252).GetString(response), @"[HTTP/]\d[.]\d\s(?<code>\d+)\s(?<reason>.+)");

                    if (m.Success)
                    {
                        int code = Convert.ToInt32(m.Groups["code"].Value);

                        if (code >= 200 && code <= 299)
                        {
                            proxyInfo.Completed = true;
                        }
                        else
                        {
                            throw new ProxyAuthenticationException(code, m.Groups["reason"].Value);
                        }
                    }
                    else
                    {
                        throw new ProxyAuthenticationException(0, "Invalid proxy message response.");
                    }

                    break;

                case ProxyType.ptSOCKS4:
                case ProxyType.ptSOCKS4a:

                    if (response[1] == 0x5A)
                    {
                        proxyInfo.Completed = true;
                    }
                    else
                    {
                        switch (response[1])
                        {
                            case 0x5B:

                                throw new ProxyAuthenticationException(response[1], "Request rejected or failed.");

                            case 0x5C:

                                throw new ProxyAuthenticationException(response[1], "Client is not running identd.");

                            case 0x5D:

                                throw new ProxyAuthenticationException(response[1], "Client's identd could not confirm the user ID string in the request.");
                        }
                    }

                    break;

                case ProxyType.ptSOCKS5:

                    switch (proxyInfo.SOCKS5Phase)
                    {
                        case SOCKS5Phase.spGreeting:

                            if (response[1] != 0xFF)
                            {
                                proxyInfo.SOCKS5Authentication = (SOCKS5AuthMode)Enum.ToObject(typeof(SOCKS5AuthMode), response[1]);

                                switch (proxyInfo.SOCKS5Authentication)
                                {
                                    case SOCKS5AuthMode.saNoAuth:

                                        proxyInfo.SOCKS5Phase = SOCKS5Phase.spConnecting;
                                        break;

                                    case SOCKS5AuthMode.ssUserPass:

                                        proxyInfo.SOCKS5Phase = SOCKS5Phase.spAuthenticating;
                                        break;
                                }
                            }
                            else
                            {
                                throw new ProxyAuthenticationException(0xFF, "Authentication method not supported.");
                            }

                            break;

                        case SOCKS5Phase.spConnecting:
                        case SOCKS5Phase.spAuthenticating:

                            if (response[1] == 0x00)
                            {
                                switch (proxyInfo.SOCKS5Phase)
                                {
                                    case SOCKS5Phase.spConnecting:

                                        proxyInfo.Completed = true;
                                        break;

                                    case SOCKS5Phase.spAuthenticating:

                                        proxyInfo.SOCKS5Phase = SOCKS5Phase.spConnecting;
                                        break;
                                }
                            }
                            else
                            {
                                switch (response[1])
                                {
                                    case 0x01:

                                        throw new ProxyAuthenticationException(response[1], "General Failure.");

                                    case 0x02:

                                        throw new ProxyAuthenticationException(response[1], "Connection not allowed by ruleset.");

                                    case 0x03:

                                        throw new ProxyAuthenticationException(response[1], "Network unreachable.");

                                    case 0x04:

                                        throw new ProxyAuthenticationException(response[1], "Host unreachable.");

                                    case 0x05:

                                        throw new ProxyAuthenticationException(response[1], "Connection refused by destination host.");

                                    case 0x06:

                                        throw new ProxyAuthenticationException(response[1], "TTL expired.");

                                    case 0x07:

                                        throw new ProxyAuthenticationException(response[1], "Command not supported / protocol error.");

                                    case 0x08:

                                        throw new ProxyAuthenticationException(response[1], "Address type not supported.");
                                }
                            }

                            break;
                    }

                    break;
            }
        }
예제 #6
0
        internal static byte[] GetProxyRequestData(ProxyInfo proxyInfo, IPEndPoint remoteEndPoint)
        {
            byte[] result = null;

            switch (proxyInfo.ProxyType)
            {
                case ProxyType.ptHTTP:

                    if (proxyInfo.ProxyCredential == null)
                    {
                        result = Encoding.GetEncoding(1252).GetBytes(String.Format("CONNECT {0}:{1} HTTP/1.1\r\nnHost: {0}:{1}\r\n\r\n", remoteEndPoint.Address, remoteEndPoint.Port));
                    }
                    else
                    {
                        string base64Encoding = Convert.ToBase64String(Encoding.GetEncoding(1252).GetBytes(proxyInfo.ProxyCredential.UserName + ":" + proxyInfo.ProxyCredential.Password));
                        result = Encoding.GetEncoding(1252).GetBytes(String.Format("CONNECT {0}:{1} HTTP/1.1\r\nHost: {0}:{1}\r\nAuthorization: Basic {2}\r\nProxy-Authorization: Basic {2}\r\n\r\n", remoteEndPoint.Address, remoteEndPoint.Port, base64Encoding));
                    }

                    break;

                case ProxyType.ptSOCKS4:
                case ProxyType.ptSOCKS4a:

                    if (proxyInfo.ProxyType == ProxyType.ptSOCKS4)
                    {
                        if (proxyInfo.ProxyCredential == null)
                        {
                            result = new byte[8 + 1];
                        }
                        else
                        {
                            result = new byte[8 + proxyInfo.ProxyCredential.UserName.Length + 1];
                        }
                    }
                    else
                    {
                        if (proxyInfo.ProxyCredential == null)
                        {
                            result = new byte[8 + 1 + 1];
                        }
                        else
                        {
                            result = new byte[8 + proxyInfo.ProxyCredential.UserName.Length + 1 + proxyInfo.ProxyCredential.Domain.Length + 1];
                        }
                    }

                    result[0] = 4;
                    result[1] = 1;

                    result[2] = Convert.ToByte((remoteEndPoint.Port & 0xFF00) >> 8);
                    result[3] = Convert.ToByte(remoteEndPoint.Port & 0xFF);

                    if (proxyInfo.ProxyType == ProxyType.ptSOCKS4)
                    {
                        Buffer.BlockCopy(remoteEndPoint.Address.GetAddressBytes(), 0, result, 4, 4);
                    }
                    else
                    {
                        result[4] = 0;
                        result[5] = 0;
                        result[6] = 0;
                        result[7] = 1;
                    }

                    if ((proxyInfo.ProxyCredential != null) && (proxyInfo.ProxyCredential.UserName != null))
                    {
                        Buffer.BlockCopy(Encoding.GetEncoding(1252).GetBytes(proxyInfo.ProxyCredential.UserName), 0, result, 8, proxyInfo.ProxyCredential.UserName.Length);
                    }

                    if ((proxyInfo.ProxyType == ProxyType.ptSOCKS4a) && (proxyInfo.ProxyCredential != null))
                    {
                        Buffer.BlockCopy(Encoding.GetEncoding(1252).GetBytes(proxyInfo.ProxyCredential.Domain), 0, result, 8 + proxyInfo.ProxyCredential.UserName.Length + 1, proxyInfo.ProxyCredential.Domain.Length);
                    }

                    break;

                case ProxyType.ptSOCKS5:

                    switch (proxyInfo.SOCKS5Phase)
                    {
                        case SOCKS5Phase.spIdle:

                            if (proxyInfo.ProxyCredential == null)
                            {
                                result = new byte[3];

                                result[0] = 5;
                                result[1] = 1;
                                result[2] = 0;
                            }
                            else
                            {
                                result = new byte[4];

                                result[0] = 5;
                                result[1] = 2;
                                result[2] = 0;
                                result[3] = 2;
                            }

                            proxyInfo.SOCKS5Phase = SOCKS5Phase.spGreeting;

                            break;

                        case SOCKS5Phase.spConnecting:

                            result = new byte[10];

                            result[0] = 5;
                            result[1] = 1;
                            result[2] = 0;
                            result[3] = 1;

                            Buffer.BlockCopy(remoteEndPoint.Address.GetAddressBytes(), 0, result, 4, 4);

                            result[8] = Convert.ToByte((remoteEndPoint.Port & 0xFF00) >> 8);
                            result[9] = Convert.ToByte(remoteEndPoint.Port & 0xFF);

                            break;

                        case SOCKS5Phase.spAuthenticating:

                            result = new byte[3 + proxyInfo.ProxyCredential.UserName.Length + proxyInfo.ProxyCredential.Password.Length];

                            result[0] = 5;
                            result[1] = Convert.ToByte(proxyInfo.ProxyCredential.UserName.Length);

                            Buffer.BlockCopy(Encoding.GetEncoding(1252).GetBytes(proxyInfo.ProxyCredential.UserName), 0, result, 2, proxyInfo.ProxyCredential.UserName.Length);

                            int passOffSet = 2 + proxyInfo.ProxyCredential.UserName.Length;
                            result[passOffSet] = Convert.ToByte(proxyInfo.ProxyCredential.Password.Length);

                            Buffer.BlockCopy(Encoding.GetEncoding(1252).GetBytes(proxyInfo.ProxyCredential.Password), 0, result, passOffSet + 1, proxyInfo.ProxyCredential.Password.Length);

                            break;
                    }

                    break;
            }

            return result;
        }
예제 #7
0
 public SocketConnector AddConnector(string name, IPEndPoint remoteEndPoint, ProxyInfo proxyData, EncryptType encryptType, CompressionType compressionType, ICryptoService cryptoService, int reconnectAttempts, int reconnectAttemptInterval)
 {
     return AddConnector(name, remoteEndPoint, proxyData, encryptType, compressionType, cryptoService, reconnectAttempts, reconnectAttemptInterval, new IPEndPoint(IPAddress.Any, 0));
 }
예제 #8
0
 public SocketConnector AddConnector(string name, IPEndPoint remoteEndPoint, ProxyInfo proxyData)
 {
     return AddConnector(name, remoteEndPoint, proxyData, EncryptType.etNone, CompressionType.ctNone, null, 0, 0, new IPEndPoint(IPAddress.Any, 0));
 }