Пример #1
0
        public override void PopulateBag(PropertyBag properties)
        {
            base.PopulateBag(properties);

            properties.AddValue("Url", Url);
            properties.AddValue("Headers", Headers);
        }
Пример #2
0
        private static void AddEndpoint(string name, EndPoint ep, PropertyBag properties)
        {
            IPEndPoint ip = ep as IPEndPoint;

            properties.AddValue(name, ep);

            if (ip != null)
            {
                properties.AddValue(name + "Address", ip.Address);
                properties.AddValue(name + "Port", ip.Port);
            }
        }
Пример #3
0
        /// <summary>
        /// Populate a property bag from a socket
        /// </summary>
        /// <param name="sock">The socket</param>
        /// <param name="properties">The property bag</param>
        public static void PopulateBagFromSocket(Socket sock, PropertyBag properties)
        {
            properties.AddValue("AddressFamily", sock.AddressFamily);
            properties.AddValue("SocketType", sock.SocketType);
            properties.AddValue("ProtocolType", sock.ProtocolType);

            try
            {
                // This could throw a socket exception if not a connected socket (e.g. UDP)
                AddEndpoint("RemoteEndpoint", sock.RemoteEndPoint, properties);
            }
            catch (SocketException)
            {
            }

            AddEndpoint("LocalEndpoint", sock.LocalEndPoint, properties);
        }
Пример #4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="properties"></param>
        public override void PopulateBag(PropertyBag properties)
        {
            base.PopulateBag(properties);

            if (Hostname != null)
            {
                properties.AddValue("Endpoint", new DnsEndPoint(Hostname, Port));
                properties.AddValue("Hostname", Hostname);
            }
            else
            {
                properties.AddValue("Endpoint", new IPEndPoint(Address, Port));
                properties.AddValue("Hostname", Address.ToString());
            }

            properties.AddValue("Protocol", ClientType == IpClientType.Tcp ? "TCP" : "UDP");
            properties.AddValue("Port", Port);
            properties.AddValue("Ipv6", Ipv6);
        }
Пример #5
0
        // TODO: Should merge with implementation for the general connection so that it is 100% compatible
        /// <summary>
        ///
        /// </summary>
        /// <param name="graph"></param>
        /// <param name="token"></param>
        public void ReconnectClient(NetGraph graph, ProxyToken token)
        {
            IDataAdapter client           = null;
            bool         connected        = false;
            PropertyBag  networkService   = graph.ConnectionProperties.GetRelativeBag("NetworkService");
            PropertyBag  clientProperties = graph.ConnectionProperties.GetRelativeBag("Client");
            PropertyBag  tokenProperties  = graph.ConnectionProperties.GetRelativeBag("Token");

            try
            {
                while (graph.Parent != null)
                {
                    graph = graph.Parent;
                }

                if (token != null)
                {
                    // If passed in a token we need to apply filters to it
                    token = FilterToken(token);
                }
                else
                {
                    // Use original post-filtered
                    token = (ProxyToken)networkService.GetRelativeValue("Token");
                }

                if (token.Status == NetStatusCodes.Success)
                {
                    clientProperties.Clear();

                    if (token.Client == null)
                    {
                        client = _proxyClient.Connect(token, _logger, graph.Meta, _globalMeta, clientProperties);
                    }
                    else
                    {
                        client = token.Client.Connect(token, _logger, graph.Meta, _globalMeta, clientProperties);
                    }

                    tokenProperties.Clear();
                    token.PopulateBag(tokenProperties);

                    // Negotiate SSL or other bespoke encryption mechanisms
                    if (token.Layers != null)
                    {
                        // Bind but disabling server layer
                        NetworkLayerBinding binding = DefaultBinding & ~NetworkLayerBinding.Server;

                        foreach (INetworkLayer layer in token.Layers)
                        {
                            IDataAdapter server = null;

                            layer.Negotiate(ref server, ref client, token, _logger, graph.Meta, _globalMeta, graph.ConnectionProperties, binding);
                        }
                    }

                    graph.BindEndpoint((Guid)networkService.GetRelativeValue("ClientId"), client);

                    IDataAdapter serverAdapter = networkService.GetRelativeValue("ServerAdapter");

                    if (token.NetworkDescription != null)
                    {
                        graph.NetworkDescription = token.NetworkDescription;
                    }
                    else
                    {
                        graph.NetworkDescription = String.Format("{0} <=> {1}",
                                                                 serverAdapter.Description, client.Description);
                    }

                    IDataAdapter oldClient = networkService.GetRelativeValue("ClientAdapter");

                    networkService.AddValue("ClientAdapter", client);
                    networkService.AddValue("Token", token);

                    oldClient.Dispose();

                    connected = true;
                }
                else
                {
                    _logger.LogVerbose(Properties.Resources.ProxyNetworkService_ConnectionFiltered);
                }
            }
            catch (Exception ex)
            {
                _logger.LogException(ex);
            }
            finally
            {
                if (!connected)
                {
                    try
                    {
                        if (client != null)
                        {
                            client.Dispose();
                        }
                    }
                    catch (Exception ex)
                    {
                        Logger.SystemLogger.LogException(ex);
                    }
                }
            }
        }
Пример #6
0
        /// <summary>
        /// Connect client
        /// </summary>
        /// <param name="baseAdapter"></param>
        /// <param name="connProperties"></param>
        /// <returns></returns>
        public NetGraph ConnectClient(IDataAdapter baseAdapter, PropertyBag connProperties)
        {
            IDataAdapter   server     = null;
            IDataAdapter   client     = null;
            ProxyToken     token      = null;
            NetGraph       graph      = null;
            NetGraph       retGraph   = null;
            MetaDictionary meta       = new MetaDictionary();
            PropertyBag    properties = new PropertyBag("Properties");

            try
            {
                properties.AddBag(connProperties);

                token = _proxyServer.Accept(baseAdapter, meta, _globalMeta, this);

                if (token != null)
                {
                    token = FilterToken(token);
                    if (token.Status == NetStatusCodes.Success)
                    {
                        ProxyClient proxyClient = token.Client ?? _proxyClient;

                        if (token.Bind)
                        {
                            client = proxyClient.Bind(token, _logger, meta, _globalMeta, properties.AddBag("Client"));
                        }
                        else
                        {
                            client = proxyClient.Connect(token, _logger, meta, _globalMeta, properties.AddBag("Client"));
                        }

                        server = _proxyServer.Complete(token, meta, _globalMeta, this, client);

                        if ((token.Status == NetStatusCodes.Success) && (client != null))
                        {
                            NetGraphFactory factory = token.Graph != null ? token.Graph : _factory;

                            token.PopulateBag(properties.AddBag("Token"));

                            // Negotiate SSL or other bespoke encryption mechanisms
                            if (token.Layers != null)
                            {
                                foreach (INetworkLayer layer in token.Layers)
                                {
                                    layer.Negotiate(ref server, ref client, token, _logger, meta,
                                                    _globalMeta, properties, DefaultBinding);
                                }
                            }

                            var clients = factory.GetNodes <ClientEndpointFactory>();
                            var servers = factory.GetNodes <ServerEndpointFactory>();

                            if ((clients.Length > 0) && (servers.Length > 0))
                            {
                                graph = CreateNetGraph(factory, meta, properties);

                                graph.BindEndpoint(clients[0].Id, client);
                                graph.BindEndpoint(servers[0].Id, server);
                                if (token.NetworkDescription != null)
                                {
                                    graph.NetworkDescription = token.NetworkDescription;
                                }
                                else
                                {
                                    graph.NetworkDescription = String.Format("{0} <=> {1}",
                                                                             server.Description, client.Description);
                                }

                                PropertyBag networkService = properties.AddBag("NetworkService");

                                networkService.AddValue("ClientId", clients[0].Id);
                                networkService.AddValue("ServerId", servers[0].Id);
                                networkService.AddValue("ClientAdapter", client);
                                networkService.AddValue("ServerAdapter", server);
                                networkService.AddValue("Token", token);

                                graph.Start();

                                OnNewConnection(graph);

                                retGraph = graph;
                            }
                            else
                            {
                                _logger.LogError(CANAPE.Net.Properties.Resources.ProxyNetworkService_InvalidGraph);
                            }
                        }
                    }
                    else
                    {
                        _logger.LogVerbose(CANAPE.Net.Properties.Resources.ProxyNetworkService_ConnectionFiltered);
                        server = _proxyServer.Complete(token, meta, _globalMeta, this, client);
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogException(ex);
            }
            finally
            {
                if (retGraph == null)
                {
                    try
                    {
                        if (graph != null)
                        {
                            ((IDisposable)graph).Dispose();
                        }
                        if (server != null)
                        {
                            server.Dispose();
                        }
                        if (client != null)
                        {
                            client.Dispose();
                        }
                        if (token != null)
                        {
                            token.Dispose();
                        }
                    }
                    catch (Exception ex)
                    {
                        Logger.SystemLogger.LogException(ex);
                    }
                }
            }

            return(retGraph);
        }
        private static void PopulateSslMeta(PropertyBag properties, SslStream stm)
        {
            properties.AddValue("SslProtocol", stm.SslProtocol);
            properties.AddValue("IsSigned", stm.IsSigned);
            properties.AddValue("IsMutallyAuthenticated", stm.IsMutuallyAuthenticated);
            properties.AddValue("IsEncrypted", stm.IsEncrypted);
            properties.AddValue("CipherAlgorithm", stm.CipherAlgorithm);
            properties.AddValue("CipherStrength", stm.CipherStrength);
            properties.AddValue("HashAlgorithm", stm.HashAlgorithm);
            properties.AddValue("HashStrength", stm.HashStrength);
            properties.AddValue("KeyExchangeAlgorithm", stm.KeyExchangeAlgorithm);
            properties.AddValue("KeyExchangeStrength", stm.KeyExchangeStrength);

            if (stm.LocalCertificate != null)
            {
                properties.AddValue("LocalCertificate", stm.LocalCertificate);
            }

            if (stm.RemoteCertificate != null)
            {
                properties.AddValue("RemoteCertificate", stm.RemoteCertificate);
            }
        }
Пример #8
0
        private static void PopulateSslMeta(PropertyBag properties, SslStream stm)
        {
            properties.AddValue("SslProtocol", stm.SslProtocol);
            properties.AddValue("IsSigned", stm.IsSigned);
            properties.AddValue("IsMutallyAuthenticated", stm.IsMutuallyAuthenticated);
            properties.AddValue("IsEncrypted", stm.IsEncrypted);
            properties.AddValue("CipherAlgorithm", stm.CipherAlgorithm);
            properties.AddValue("CipherStrength", stm.CipherStrength);
            properties.AddValue("HashAlgorithm", stm.HashAlgorithm);
            properties.AddValue("HashStrength", stm.HashStrength);

            if(stm.LocalCertificate != null)
            {
                properties.AddValue("LocalCertificate", stm.LocalCertificate);
            }

            if (stm.RemoteCertificate != null)
            {
                properties.AddValue("RemoteCertificate", stm.RemoteCertificate);
                properties.AddValue("KeyExchangeAlgorithm", stm.KeyExchangeAlgorithm);
                properties.AddValue("KeyExchangeStrength", stm.KeyExchangeStrength);
            }
        }
Пример #9
0
        public override void PopulateBag(PropertyBag properties)
        {
            base.PopulateBag(properties);

            properties.AddValue("Url", Url);
            properties.AddValue("Headers", Headers);
        }
Пример #10
0
        private static void AddEndpoint(string name, EndPoint ep, PropertyBag properties)
        {
            IPEndPoint ip = ep as IPEndPoint;
            properties.AddValue(name, ep);

            if(ip != null)
            {
                properties.AddValue(name + "Address", ip.Address);
                properties.AddValue(name + "Port", ip.Port);
            }
        }
Пример #11
0
        /// <summary>
        /// Populate a property bag from a socket
        /// </summary>
        /// <param name="sock">The socket</param>
        /// <param name="properties">The property bag</param>
        public static void PopulateBagFromSocket(Socket sock, PropertyBag properties)
        {
            properties.AddValue("AddressFamily", sock.AddressFamily);
            properties.AddValue("SocketType", sock.SocketType);
            properties.AddValue("ProtocolType", sock.ProtocolType);

            try
            {
                // This could throw a socket exception if not a connected socket (e.g. UDP)
                AddEndpoint("RemoteEndpoint", sock.RemoteEndPoint, properties);
            }
            catch (SocketException)
            {
            }

            AddEndpoint("LocalEndpoint", sock.LocalEndPoint, properties);
        }
Пример #12
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="properties"></param>
        public override void PopulateBag(PropertyBag properties)
        {
            base.PopulateBag(properties);

            if (Hostname != null)
            {
                properties.AddValue("Endpoint", new DnsEndPoint(Hostname, Port));
                properties.AddValue("Hostname", Hostname);
            }
            else
            {
                properties.AddValue("Endpoint", new IPEndPoint(Address, Port));
                properties.AddValue("Hostname", Address.ToString());
            }

            properties.AddValue("Protocol", ClientType == IpClientType.Tcp ? "TCP" : "UDP");
            properties.AddValue("Port", Port);
            properties.AddValue("Ipv6", Ipv6);
        }