/// <summary> /// Accept connection (just returns a default token) /// </summary> /// <param name="adapter">The server adapter</param> /// <param name="globalMeta"></param> /// <param name="meta"></param> /// <param name="service"></param> /// <returns>The proxy token</returns> public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service) { ProxyToken token = new PassThroughToken(adapter); token.Layers = _layers.CreateLayers(_logger); return token; }
private void btnStart_Click(object sender, EventArgs e) { try { if (_service == null) { StartService(); DocumentControl.SetIcon(_document, "NetService_Started", Properties.Resources.Network_Map_Started); btnStart.Text = "Stop"; comboBoxNetgraph.Enabled = false; EnableControl(false); } else { StopService(); } } catch (NetServiceException ex) { Exception dispEx = ex; _service = null; if (ex.InnerException != null) { dispEx = ex.InnerException; } MessageBox.Show(this, dispEx.Message, CANAPE.Properties.Resources.MessageBox_ErrorString, MessageBoxButtons.OK, MessageBoxIcon.Error); } catch (Exception ex) { MessageBox.Show(this, ex.Message, CANAPE.Properties.Resources.MessageBox_ErrorString, MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public override ProxyNetworkService Create(Logger logger) { ProxyNetworkService ret = null; if (logger == null) { logger = Logger.GetSystemLogger(); } try { ProxyServer server = new PassThroughProxyServer(logger, _layers); ret = new ProxyNetworkService(_packets, new SerialPortProxyListener(ServerPort), _netGraph == null ? BuildDefaultProxyFactory() : _netGraph.Factory, logger, _globalMeta, _history, _credentials, server, new SerialPortProxyClient(ClientPort), null, Timeout.Infinite, false); ret.DefaultBinding = NetworkLayerBinding.ClientAndServer; } catch (Exception ex) { if (ex is NetServiceException) { throw; } throw new NetServiceException("Error creating service", ex); } return(ret); }
public HttpProxyClientDataAdapter(FullHttpProxyServer server, ProxyNetworkService service, Logger logger) { _server = server; _service = service; _cancellationSource = new CancellationTokenSource(); _conns = new LockedQueue <ProxyConnection>(-1, _cancellationSource.Token); _logger = logger; _graphs = new List <NetGraph>(); Description = "HTTP Proxy Server"; }
private void SetupService(ProxyNetworkService graph) { _service = graph; comboBoxNetGraph.Items.Clear(); comboBoxNetGraph.SelectedItem = null; metaEditorControl.Meta = null; propertyBagViewerControl.UpdateProperties(null); listViewNetGraph.Items.Clear(); }
/// <summary> /// Create the network service from this document /// </summary> /// <param name="logger">The logger for the service</param> /// <returns>The new network service</returns> public override ProxyNetworkService Create(Logger logger) { ProxyNetworkService ret = null; if (logger == null) { logger = Logger.GetSystemLogger(); } if ((_port <= 0) || (_port > 65535)) { throw new NetServiceException("Must provide a valid port"); } else { try { ProxyServer server = new FixedProxyServer(logger, _destination, _port, _udp ? IpProxyToken.IpClientType.Udp : IpProxyToken.IpClientType.Tcp, _ipv6, _layers); ProxyClient client = null; if (_clientFactory != null) { client = _clientFactory.Create(logger); } else { client = new IpProxyClient(); } ret = new ProxyNetworkService( _packets, CreateListener(logger), _netGraph == null ? BuildDefaultProxyFactory() : _netGraph.Factory, logger, _globalMeta, _history, _credentials, server, client, null, Timeout.Infinite, false); ret.DefaultBinding = NetworkLayerBinding.Client; } catch (SocketException ex) { throw new NetServiceException("Error creating network service", ex); } catch (IOException ex) { throw new NetServiceException("Error creating network service", ex); } return(ret); } }
void OnServiceStop() { CloseLogFiles(); DocumentControl.SetIcon(_document, null, null); if (!IsDisposed) { netGraphNodesControl.Service = null; listViewConns.Items.Clear(); btnStart.Text = "Start"; comboBoxNetgraph.Enabled = true; EnableControl(true); _service = null; } }
private void StartService() { if (checkBoxClearOnStart.Checked) { _document.GlobalMeta.Clear(); } _service = _document.Create(eventLogControl.Logger); _service.EditPacketEvent += new EventHandler <EditPacketEventArgs>(_service_EditPacketEvent); _service.FilterLogPacketEvent += new EventHandler <FilterPacketLogEventArgs>(_service_FilterLogPacketEvent); _service.NewConnectionEvent += new EventHandler <ConnectionEventArgs>(_service_NewConnectionEvent); _service.CloseConnectionEvent += new EventHandler <ConnectionEventArgs>(_service_CloseConnectionEvent); _service.ServiceStoppedEvent += new EventHandler(_service_ServiceStoppedEvent); _service.ResolveCredentials += ResolveCredentials; _service.Start(); netGraphNodesControl.Service = _service; injectPacketControl.Service = _service; }
/// <summary> /// /// </summary> /// <param name="adapter"></param> /// <param name="meta"></param> /// <param name="globalMeta"></param> /// <param name="service"></param> /// <returns></returns> public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service) { ProxyToken token = null; TcpClientDataAdapter tcpAdapter = adapter as TcpClientDataAdapter; if (_config.SslConfig.Enabled) { IDataAdapter client = null; INetworkLayer ssl = new SslNetworkLayer(_config.SslConfig); ssl.Negotiate(ref adapter, ref client, null, _logger, null, null, new PropertyBag("Root"), NetworkLayerBinding.Server); } DataAdapterToStream stm = new DataAdapterToStream(adapter); DataReader reader = new DataReader(stm); try { HttpRequestHeader header = HttpParser.ReadRequestHeader(reader, false, _logger); token = HandleOtherRequest(header, stm, tcpAdapter); } catch (HttpStreamParserException ex) { _logger.LogError(CANAPE.Net.Properties.Resources.HttpProxyServer_InvalidRequest, ex.Message); // TODO: Put in some decent error codes ReturnResponse(null, 400, "Bad Request", "GET", HttpVersion.Version11, stm); } catch (EndOfStreamException) { token = null; } return token; }
/// <summary> /// Create the network service /// </summary> /// <param name="logger">The logger to use</param> /// <returns>The service</returns> public override ProxyNetworkService Create(Logger logger) { if (_concurrentConnections <= 0) { throw new NetServiceException(CANAPE.Documents.Properties.Resources.NetAutoClientDocument_InvalidConncurrentConnections); } if (_specifyTimeout && (_timeoutMilliSeconds < 0)) { throw new NetServiceException(CANAPE.Documents.Properties.Resources.NetAutoClientDocument_InvalidTimeout); } if (_factory == null) { throw new NetServiceException(CANAPE.Documents.Properties.Resources.NetAutoClientDocument_NoFactory); } ProxyNetworkService service = base.Create(logger); ((AutoNetworkListener)service.Listener).SetService(service); return(service); }
/// <summary> /// /// </summary> /// <param name="adapter"></param> /// <param name="globalMeta"></param> /// <param name="meta"></param> /// <param name="service"></param> /// <returns></returns> public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service) { DataAdapterToStream stm = new DataAdapterToStream(adapter); return HandleConnectRequest(stm); }
/// <summary> /// Method to create a network service /// </summary> /// <param name="logger">The logger to use</param> /// <returns>The network service</returns> /// <exception cref="NetServiceException">Thrown in configuration invalid</exception> public override ProxyNetworkService Create(Logger logger) { ProxyNetworkService ret = null; if (logger == null) { logger = Logger.GetSystemLogger(); } if ((_port < 0) || (_port > 65535)) { throw new NetServiceException(Properties.Resources.GenericProxyDocument_MustSpecifyAValidPort); } else { try { List <ProxyFilter> filters = new List <ProxyFilter>(); foreach (ProxyFilterFactory item in _filters) { filters.Add(item.CreateFilter()); } ProxyServer server = CreateServer(logger); ProxyClient client = null; if (_clientFactory != null) { client = _clientFactory.Create(logger); } else { client = new IpProxyClient(); } INetworkListener listener = null; if (NetUtils.OSSupportsIPv4) { listener = new TcpNetworkListener(_anyBind, false, _port, logger, false); } if (_ipv6Bind && NetUtils.OSSupportsIPv6) { INetworkListener ipv6Listener = new TcpNetworkListener(_anyBind, true, _port, logger, false); if (listener != null) { listener = new AggregateNetworkListener(listener, ipv6Listener); } else { listener = ipv6Listener; } } if (listener == null) { throw new NetServiceException(CANAPE.Documents.Properties.Resources.NetServiceDocument_CannotSetupListener); } ret = new ProxyNetworkService( _packets, listener, _netGraph == null ? BuildDefaultProxyFactory() : _netGraph.Factory, logger, _globalMeta, _history, _credentials, server, client, filters.ToArray(), Timeout.Infinite, false); ret.DefaultBinding = CANAPE.Net.Layers.NetworkLayerBinding.ClientAndServer; } catch (SocketException ex) { throw new NetServiceException(Properties.Resources.GenericProxyDocument_ErrorCreatingService, ex); } catch (IOException ex) { throw new NetServiceException(Properties.Resources.GenericProxyDocument_ErrorCreatingService, ex); } return(ret); } }
private ProxyToken HandleOtherRequest(HttpRequestHeader header, DataAdapterToStream stm, ProxyNetworkService service) { Uri url; if (Uri.TryCreate(header.Path, UriKind.Absolute, out url)) { // Use generic token so filters don't get used ProxyToken ret = new ProxyToken(); ret.State.Add("url", url); ret.State.Add("stm", stm); ret.State.Add("header", header); ret.Client = new HttpProxyDummyClient(this, service); ret.Graph = _factory; return ret; } else { _logger.LogError(CANAPE.Net.Properties.Resources.HttpProxyServer_InvalidUrl, header.Path); // TODO: Put in some decent error codes ReturnResponse(null, 400, "Bad Request", header.Method, header.Version, stm); return null; } }
/// <summary> /// /// </summary> /// <param name="adapter"></param> /// <param name="meta"></param> /// <param name="globalMeta"></param> /// <param name="service"></param> /// <returns></returns> public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service) { ProxyToken token = null; TcpClientDataAdapter tcpAdapter = adapter as TcpClientDataAdapter; if (_config.SslConfig.Enabled) { IDataAdapter client = null; INetworkLayer ssl = new SslNetworkLayer(_config.SslConfig); ssl.Negotiate(ref adapter, ref client, null, _logger, null, null, new PropertyBag("Root"), NetworkLayerBinding.Server); } DataAdapterToStream stm = new DataAdapterToStream(adapter); DataReader reader = new DataReader(stm); try { HttpRequestHeader header = HttpParser.ReadRequestHeader(reader, false, _logger); token = HandleOtherRequest(header, stm, tcpAdapter); } catch (HttpStreamParserException ex) { _logger.LogError(CANAPE.Net.Properties.Resources.HttpProxyServer_InvalidRequest, ex.Message); // TODO: Put in some decent error codes ReturnResponse(null, 400, "Bad Request", "GET", HttpVersion.Version11, stm); } catch (EndOfStreamException) { token = null; } return(token); }
/// <summary> /// Method to create the network service /// </summary> /// <param name="logger">The logger to use</param> /// <returns>The network service</returns> /// <exception cref="NetServiceException">Thrown if invalid configuration</exception> public override ProxyNetworkService Create(Logger logger) { ProxyNetworkService ret = null; if (logger == null) { logger = Logger.GetSystemLogger(); } if ((_port <= 0) || (_port > 65535)) { throw new NetServiceException(Properties.Resources.FixedProxyDocument_MustProvideValidPort); } else if ((_localPort < 0) || (_localPort > 65535)) { throw new NetServiceException(Properties.Resources.FixedProxyDocument_MustProvideValidLocalPort); } else { try { ProxyServer server = new FixedProxyServer(logger, _host, _port, _udp ? IpProxyToken.IpClientType.Udp : IpProxyToken.IpClientType.Tcp, _ipv6, _layers); ProxyClient client = null; if (_clientFactory != null) { client = _clientFactory.Create(logger); } else { client = new IpProxyClient(); } INetworkListener listener = null; if (!_udp) { if (NetUtils.OSSupportsIPv4) { listener = new TcpNetworkListener(_anyBind, false, _localPort, logger, false); } if (_ipv6Bind && NetUtils.OSSupportsIPv6) { INetworkListener ipv6Listener = new TcpNetworkListener(_anyBind, true, _localPort, logger, false); if (listener != null) { listener = new AggregateNetworkListener(listener, ipv6Listener); } else { listener = ipv6Listener; } } } else { if (NetUtils.OSSupportsIPv4) { listener = new UdpNetworkListener(_anyBind, false, _localPort, _enableBroadcast, logger); } if (_ipv6Bind && NetUtils.OSSupportsIPv6) { INetworkListener ipv6Listener = new UdpNetworkListener(_anyBind, true, _localPort, _enableBroadcast, logger); if (listener != null) { listener = new AggregateNetworkListener(listener, ipv6Listener); } else { listener = ipv6Listener; } } } if (listener == null) { throw new NetServiceException(CANAPE.Documents.Properties.Resources.NetServiceDocument_CannotSetupListener); } ret = new ProxyNetworkService(_packets, listener, _netGraph == null ? BuildDefaultProxyFactory() : _netGraph.Factory, logger, _globalMeta, _history, _credentials, server, client, null, Timeout.Infinite, false); ret.DefaultBinding = NetworkLayerBinding.ClientAndServer; } catch (SocketException ex) { throw new NetServiceException(Properties.Resources.FixedProxyDocument_ErrorCreatingService, ex); } catch (IOException ex) { throw new NetServiceException(Properties.Resources.FixedProxyDocument_ErrorCreatingService, ex); } return(ret); } }
/// <summary> /// /// </summary> /// <param name="token"></param> /// <param name="meta"></param> /// <param name="globalMeta"></param> /// <param name="service"></param> /// <param name="client"></param> /// <returns></returns> public override IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client) { IDataAdapter ret = null; // An empty initial request indicates we are a full connection if (token.State.ContainsKey("header")) { HttpRequestHeader initialRequest = (HttpRequestHeader)token.State["header"]; DataAdapterToStream stm = (DataAdapterToStream)token.State["stm"]; if (token.Status == NetStatusCodes.Success) { if (initialRequest.IsConnect) { ReturnResponse(null, 200, "Connection established", initialRequest.Method, initialRequest.Version, stm); // Connect is transparent ret = new StreamDataAdapter(stm); } else { // Use a proxy adapter ret = new HttpProxyServerAdapter(stm, initialRequest, _logger); } } else { ReturnResponse(initialRequest, 404, "Not Found", initialRequest.Method, HttpVersion.Version11, stm); } } else { ret = (IDataAdapter)token.State["adapter"]; } token.State.Clear(); return ret; }
/// <summary> /// /// </summary> /// <param name="token"></param> /// <param name="client"></param> /// <param name="globalMeta"></param> /// <param name="meta"></param> /// <param name="service"></param> /// <returns></returns> public override IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client) { IDataAdapter ret = null; HttpProxyToken httpToken = (HttpProxyToken)token; DataAdapterToStream stm = httpToken.Adapter; if (httpToken.Status == NetStatusCodes.Success) { if (httpToken.IsHTTPProxyClient) { // We don't have to do anything as such, other than send back any smuggled data if it was a connect call if (httpToken.Response != null) { stm.Write(httpToken.Response, 0, httpToken.Response.Length); } httpToken.Adapter = null; if (httpToken.Connect) { // With CONNECT the data stream is transparent ret = new StreamDataAdapter(stm); } else { // For anything else, rebuild the original headers so it can flow through the graph StringBuilder builder = new StringBuilder(); foreach (string s in httpToken.Headers) { builder.Append(s); } ret = new PrefixedDataAdapter(new StreamDataAdapter(stm), GeneralUtils.MakeByteArray(builder.ToString())); } } else { if (httpToken.Connect) { ReturnResponse(200, "Connection established", stm); httpToken.Adapter = null; ret = new StreamDataAdapter(stm); } else { StringBuilder builder = new StringBuilder(); string[] reqValues = httpToken.Headers[0].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); // Downgrade to version 1.0 httpToken.Headers[0] = reqValues[0] + " " + httpToken.Url.PathAndQuery + " HTTP/1.0\r\n"; foreach (string s in httpToken.Headers) { // Remove proxy headers if (!s.StartsWith("proxy", StringComparison.OrdinalIgnoreCase)) { builder.Append(s); } } httpToken.Adapter = null; ret = new PrefixedDataAdapter(new StreamDataAdapter(stm), GeneralUtils.MakeByteArray(builder.ToString())); } } } else { ReturnResponse(404, "Not Found", stm); } return ret; }
public void SetService(ProxyNetworkService service) { _service = service; _service.CloseConnectionEvent += new EventHandler <ConnectionEventArgs>(_service_CloseConnectionEvent); }
/// <summary> /// Method to create a network service /// </summary> /// <param name="logger">The logger to use</param> /// <returns>The network service</returns> /// <exception cref="NetServiceException">Thrown in configuration invalid</exception> public override ProxyNetworkService Create(Logger logger) { ProxyNetworkService ret = null; if (logger == null) { throw new ArgumentNullException("logger"); } if ((LocalPort < 0) || (LocalPort > 65535)) { throw new NetServiceException(Properties.Resources.GenericProxyDocument_MustSpecifyAValidPort); } else { try { List <ProxyFilter> filters = new List <ProxyFilter>(); foreach (ProxyFilterFactory item in Filters) { filters.Add(item.CreateFilter()); } ProxyServer server = CreateServer(logger); ProxyClient client = null; if (Client != null) { client = Client.Create(logger); } else { client = new IpProxyClient(); } INetworkListener listener = null; if (NetUtils.OSSupportsIPv4) { listener = new TcpNetworkListener(AnyBind, false, LocalPort, logger, false); } if (Ipv6Bind && NetUtils.OSSupportsIPv6) { INetworkListener ipv6Listener = new TcpNetworkListener(AnyBind, true, LocalPort, logger, false); if (listener != null) { listener = new AggregateNetworkListener(listener, ipv6Listener); } else { listener = ipv6Listener; } } if (listener == null) { throw new NetServiceException(CANAPE.Net.Templates.Properties.Resources.NetServiceDocument_CannotSetupListener); } ret = new ProxyNetworkService(listener, Graph ?? BuildDefaultProxyFactory(), logger, _globalMeta, server, client, filters.ToArray(), Timeout.Infinite, false); ret.DefaultBinding = CANAPE.Net.Layers.NetworkLayerBinding.ClientAndServer; } catch (SocketException ex) { throw new NetServiceException(Properties.Resources.GenericProxyDocument_ErrorCreatingService, ex); } catch (IOException ex) { throw new NetServiceException(Properties.Resources.GenericProxyDocument_ErrorCreatingService, ex); } return(ret); } }
public HttpProxyDummyClient(FullHttpProxyServer server, ProxyNetworkService service) { _server = server; _service = service; }
/// <summary> /// Complete the proxy connection by passing back the token and getting a new IDataAdapter /// </summary> /// <param name="token">The token returned from client</param> /// <param name="globalMeta">Global meta object</param> /// <param name="meta">Meta object</param> /// <param name="service">The service which contains this server</param> /// <param name="client">The client adapter which was created</param> /// <returns>The final data adapter, should be used for further work</returns> public abstract IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client);
private void HandleFrame(LayerSectionFilter filter, DataFrame frame) { string name = GenerateName(filter, frame); GraphEntry startEntry = null; lock (_graphEntries) { if (!_shuttingDown) { if (_graphEntries.ContainsKey(name)) { _graphEntries[name].GetInputAdapter(_direction).Enqueue(frame); } else { LayerSectionDataAdapter clientAdapter = new LayerSectionDataAdapter(this); LayerSectionDataAdapter serverAdapter = new LayerSectionDataAdapter(_linkedNode); if (_direction == LayerSectionGraphDirection.ClientToServer) { LayerSectionDataAdapter temp = clientAdapter; clientAdapter = serverAdapter; serverAdapter = temp; } var clients = filter.Factory.GetNodes <ClientEndpointFactory>(); var servers = filter.Factory.GetNodes <ServerEndpointFactory>(); if ((clients.Length > 0) && (servers.Length > 0)) { MetaDictionary meta = filter.IsolatedGraph ? new MetaDictionary() : Graph.Meta; NetGraph graph = filter.Factory.Create(Graph.Logger, Graph, Graph.GlobalMeta, meta, Graph.ConnectionProperties.AddBag(name)); graph.Name = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", Name, name); startEntry = new GraphEntry(filter, clientAdapter, serverAdapter, graph, clients[0].Id, servers[0].Id, ProxyNetworkService.GetLayerBinding(Graph)); startEntry.GetInputAdapter(_direction).Enqueue(frame); _graphEntries[name] = startEntry; } else { throw new ArgumentException(CANAPE.Net.Properties.Resources.LayerSectionNode_InvalidGraph); } } } } // Ensure this is done outside the lock if (startEntry != null) { startEntry.NegotiationThread = new Thread(() => { try { startEntry.Start(); } catch (Exception ex) { Graph.Logger.LogException(ex); lock (_graphEntries) { _graphEntries.Remove(name); startEntry.Dispose(); } } } ); startEntry.NegotiationThread.CurrentUICulture = Thread.CurrentThread.CurrentUICulture; startEntry.NegotiationThread.IsBackground = true; startEntry.NegotiationThread.Start(); } }
/// <summary> /// Accept a new proxy connection /// </summary> /// <param name="adapter">The data adapter to use</param> /// <param name="globalMeta">Global meta object</param> /// <param name="meta">Meta object</param> /// <param name="service">The service which contains this server</param> /// <returns>A object which implements IProxyToken</returns> public abstract ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service);
public HttpProxyClientDataAdapter(FullHttpProxyServer server, ProxyNetworkService service, Logger logger) { _server = server; _service = service; _cancellationSource = new CancellationTokenSource(); _conns = new LockedQueue<ProxyConnection>(-1, _cancellationSource.Token); _logger = logger; _graphs = new List<NetGraph>(); Description = "HTTP Proxy Server"; }
/// <summary> /// /// </summary> /// <param name="adapter"></param> /// <param name="globalMeta"></param> /// <param name="meta"></param> /// <param name="service"></param> /// <returns></returns> public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service) { HttpProxyToken token = null; if (_ssl != null) { IDataAdapter client = null; _ssl.Negotiate(ref adapter, ref client, null, _logger, null, null, new PropertyBag("Root"), NetworkLayerBinding.Server); } DataAdapterToStream stm = new DataAdapterToStream(adapter); List<string> headers = new List<string>(); // Read out HTTP headers try { while (true) { string nextLine = GeneralUtils.ReadLine(stm); headers.Add(nextLine); if (nextLine.Trim('\r', '\n').Length == 0) { break; } } } catch (EndOfStreamException) { // Pass on the exception if we got killed half way through if (headers.Count > 0) { throw; } } if (headers.Count > 0) { string[] reqValues = headers[0].Trim().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); // Check it at least has a VERB and a PATH if (reqValues.Length > 1) { if (reqValues[0].Equals("CONNECT", StringComparison.OrdinalIgnoreCase)) { token = HandleConnect(reqValues[1], headers.ToArray(), stm); } else { token = HandleOtherRequest(reqValues[1], headers.ToArray(), stm); } } else { _logger.LogError(CANAPE.Net.Properties.Resources.HttpProxyServer_InvalidRequest, headers[0]); // TODO: Put in some decent error codes ReturnResponse(500, "Server Error", stm); } } return token; }
public HttpProxyDummyClient(FullHttpProxyServer server, ProxyNetworkService service) { _server = server; _service = service; }
private ProxyToken HandleOtherRequest(HttpRequestHeader header, DataAdapterToStream stm, ProxyNetworkService service) { Uri url; if (Uri.TryCreate(header.Path, UriKind.Absolute, out url)) { // Use generic token so filters don't get used ProxyToken ret = new ProxyToken(); ret.State.Add("url", url); ret.State.Add("stm", stm); ret.State.Add("header", header); ret.Client = new HttpProxyDummyClient(this, service); ret.Graph = _factory; return(ret); } else { _logger.LogError(CANAPE.Net.Properties.Resources.HttpProxyServer_InvalidUrl, header.Path); // TODO: Put in some decent error codes ReturnResponse(null, 400, "Bad Request", header.Method, header.Version, stm); return(null); } }
/// <summary> /// /// </summary> /// <param name="adapter"></param> /// <param name="meta"></param> /// <param name="globalMeta"></param> /// <param name="service"></param> /// <returns></returns> public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service) { ProxyToken token = null; if (_config.SslConfig.Enabled) { IDataAdapter client = null; INetworkLayer ssl = new TlsNetworkLayer(_config.SslConfig); ssl.Negotiate(ref adapter, ref client, null, _logger, null, null, new PropertyBag("Root"), NetworkLayerBinding.Server); } if (adapter is HttpProxyDataAdapter) { HttpProxyDataAdapter proxyAdapter = (HttpProxyDataAdapter)adapter; token = new FullHttpProxyToken(proxyAdapter.Url.Host, proxyAdapter.Url.Port); token.State.Add("adapter", adapter); } else { DataAdapterToStream stm = new DataAdapterToStream(adapter); DataReader reader = new DataReader(stm); try { HttpRequestHeader header = HttpParser.ReadRequestHeader(reader, false, _logger); if (HandleProxyAuthentication(reader, stm, ref header)) { // We just have a connect if (header.IsConnect) { token = HandleConnect(header, stm); } else { token = HandleOtherRequest(header, stm, service); } } } catch (HttpStreamParserException ex) { _logger.LogError(CANAPE.Net.Properties.Resources.HttpProxyServer_InvalidRequest, ex.Message); // TODO: Put in some decent error codes ReturnResponse(null, 400, "Bad Request", "GET", HttpVersion.Version11, stm); } catch (EndOfStreamException) { token = null; } } return(token); }
/// <summary> /// Accept connection (just returns a default token) /// </summary> /// <param name="adapter">The server adapter</param> /// <param name="globalMeta"></param> /// <param name="meta"></param> /// <param name="service"></param> /// <returns>The proxy token</returns> public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service) { ProxyToken token = new PassThroughToken(adapter); token.Layers = _layers.CreateLayers(_logger); return(token); }
/// <summary> /// Accept a new proxy connection /// </summary> /// <param name="adapter">The data adapter to use</param> /// <param name="globalMeta">Global meta object</param> /// <param name="meta">Meta object</param> /// <param name="service">The service which contains this server</param> /// <returns>A object which implements IProxyToken</returns> public abstract ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service);
/// <summary> /// /// </summary> /// <param name="token"></param> /// <param name="meta"></param> /// <param name="globalMeta"></param> /// <param name="service"></param> /// <param name="client"></param> /// <returns></returns> public override IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client) { IDataAdapter ret = null; // An empty initial request indicates we are a full connection if (token.State.ContainsKey("header")) { HttpRequestHeader initialRequest = (HttpRequestHeader)token.State["header"]; DataAdapterToStream stm = (DataAdapterToStream)token.State["stm"]; if (token.Status == NetStatusCodes.Success) { if (initialRequest.IsConnect) { ReturnResponse(null, 200, "Connection established", initialRequest.Method, initialRequest.Version, stm); // Connect is transparent ret = new StreamDataAdapter(stm); } else { // Use a proxy adapter ret = new HttpProxyServerAdapter(stm, initialRequest, _logger); } } else { ReturnResponse(initialRequest, 404, "Not Found", initialRequest.Method, HttpVersion.Version11, stm); } } else { ret = (IDataAdapter)token.State["adapter"]; } token.State.Clear(); return(ret); }
/// <summary> /// /// </summary> /// <param name="adapter"></param> /// <param name="meta"></param> /// <param name="globalMeta"></param> /// <param name="service"></param> /// <returns></returns> public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service) { FixedProxyToken token = new FixedProxyToken(_address, _hostName, _port, _clientType, _ipv6, adapter); token.Layers = _layers.CreateLayers(_logger); return(token); }
/// <summary> /// Complete the client connection, just returns the original adapter /// </summary> /// <param name="token">The proxy token</param> /// <param name="client"></param> /// <param name="globalMeta"></param> /// <param name="meta"></param> /// <param name="service"></param> /// <returns>The data adapter</returns> public override IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client) { PassThroughToken passToken = (PassThroughToken)token; IDataAdapter adapter = passToken.Adapter; if (token.Status != NetStatusCodes.Success) { return null; } else { // Set to null to prevent Dispose being called passToken.Adapter = null; return adapter; } }
/// <summary> /// /// </summary> /// <param name="adapter"></param> /// <param name="globalMeta"></param> /// <param name="meta"></param> /// <param name="service"></param> /// <returns></returns> public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service) { DataAdapterToStream stm = new DataAdapterToStream(adapter); return(HandleConnectRequest(stm)); }
/// <summary> /// Create the base service /// </summary> /// <param name="logger">The logger to use</param> /// <returns>The new network service</returns> public override ProxyNetworkService Create(Logger logger) { ProxyNetworkService ret = null; if (logger == null) { logger = Logger.SystemLogger; } if ((LocalPort < 0) || (LocalPort > 65535)) { throw new NetServiceException(Properties.Resources.NetServerDocument_ValidPort); } else if (ServerFactory == null) { throw new NetServiceException(Properties.Resources.NetServerDocument_MustSpecifyServer); } else { try { ProxyServer server = new PassThroughProxyServer(logger, Layers); ProxyClient client = new NetServerProxyClient(ServerFactory); INetworkListener listener = null; if (!UdpEnable) { if (NetUtils.OSSupportsIPv4) { listener = new TcpNetworkListener(AnyBind, false, LocalPort, logger, false); } if (Ipv6Bind && NetUtils.OSSupportsIPv6) { INetworkListener ipv6Listener = new TcpNetworkListener(AnyBind, true, LocalPort, logger, false); if (listener != null) { listener = new AggregateNetworkListener(listener, ipv6Listener); } else { listener = ipv6Listener; } } } else { if (NetUtils.OSSupportsIPv4) { listener = new UdpNetworkListener(AnyBind, false, LocalPort, EnableBroadcast, logger); } if (Ipv6Bind && NetUtils.OSSupportsIPv6) { INetworkListener ipv6Listener = new UdpNetworkListener(AnyBind, true, LocalPort, EnableBroadcast, logger); if (listener != null) { listener = new AggregateNetworkListener(listener, ipv6Listener); } else { listener = ipv6Listener; } } } if (listener == null) { throw new NetServiceException(Properties.Resources.NetServiceDocument_CannotSetupListener); } ret = new ProxyNetworkService(listener, Graph ?? BuildDefaultProxyFactory(), logger, _globalMeta, server, client, null, Timeout.Infinite, false); ret.DefaultBinding = NetworkLayerBinding.Server; } catch (SocketException ex) { throw new NetServiceException(Properties.Resources.NetServerDocument_ErrorCreatingServer, ex); } catch (IOException ex) { throw new NetServiceException(Properties.Resources.NetServerDocument_ErrorCreatingServer, ex); } return(ret); } }
/// <summary> /// /// </summary> /// <param name="adapter"></param> /// <param name="meta"></param> /// <param name="globalMeta"></param> /// <param name="service"></param> /// <returns></returns> public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service) { FixedProxyToken token = new FixedProxyToken(_address, _hostName, _port, _clientType, _ipv6, adapter); token.Layers = _layers.CreateLayers(_logger); return token; }
/// <summary> /// /// </summary> /// <param name="token"></param> /// <param name="client"></param> /// <param name="globalMeta"></param> /// <param name="meta"></param> /// <param name="service"></param> /// <returns></returns> public override IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client) { SocksProxyToken socksToken = (SocksProxyToken)token; if (IsSupported(socksToken.Version)) { if (socksToken.Version == 4) { return HandleSocksV4Response(socksToken); } else if (socksToken.Version == 5) { return HandleSocksV5Response(socksToken); } else { // We shouldn't get here throw new InvalidOperationException(CANAPE.Net.Properties.Resources.SocksProxyServer_IsSupportedError); } } else { _logger.LogError(CANAPE.Net.Properties.Resources.SocksProxyServer_UnsupportedTokenVersion, socksToken.Version); } return null; }
/// <summary> /// Method to create the network service /// </summary> /// <param name="logger">The logger to use</param> /// <returns>The network service</returns> /// <exception cref="NetServiceException">Thrown if invalid configuration</exception> public override ProxyNetworkService Create(Logger logger) { ProxyNetworkService ret = null; if (logger == null) { throw new ArgumentNullException(nameof(logger)); } if ((Port <= 0) || (Port > 65535)) { throw new NetServiceException(Properties.Resources.FixedProxyDocument_MustProvideValidPort); } else if ((LocalPort < 0) || (LocalPort > 65535)) { throw new NetServiceException(Properties.Resources.FixedProxyDocument_MustProvideValidLocalPort); } else { try { ProxyServer server = new FixedProxyServer(logger, Host, Port, UdpEnable ? IpProxyToken.IpClientType.Udp : IpProxyToken.IpClientType.Tcp, Ipv6, Layers); ProxyClient client = Client != null?Client.Create(logger) : new IpProxyClient(); INetworkListener listener = null; if (UdpEnable) { if (NetUtils.OSSupportsIPv4) { listener = new UdpNetworkListener(AnyBind, false, LocalPort, EnableBroadcast, logger); } if (Ipv6Bind && NetUtils.OSSupportsIPv6) { INetworkListener ipv6Listener = new UdpNetworkListener(AnyBind, true, LocalPort, EnableBroadcast, logger); if (listener != null) { listener = new AggregateNetworkListener(listener, ipv6Listener); } else { listener = ipv6Listener; } } } else { if (NetUtils.OSSupportsIPv4) { listener = new TcpNetworkListener(AnyBind, false, LocalPort, logger, false); } if (Ipv6Bind && NetUtils.OSSupportsIPv6) { INetworkListener ipv6Listener = new TcpNetworkListener(AnyBind, true, LocalPort, logger, false); if (listener != null) { listener = new AggregateNetworkListener(listener, ipv6Listener); } else { listener = ipv6Listener; } } } if (listener == null) { throw new NetServiceException(CANAPE.Net.Templates.Properties.Resources.NetServiceDocument_CannotSetupListener); } ret = new ProxyNetworkService(listener, Graph ?? BuildDefaultProxyFactory(), logger, _globalMeta, server, client, null, Timeout.Infinite, false); ret.DefaultBinding = NetworkLayerBinding.ClientAndServer; } catch (SocketException ex) { throw new NetServiceException(Properties.Resources.FixedProxyDocument_ErrorCreatingService, ex); } catch (IOException ex) { throw new NetServiceException(Properties.Resources.FixedProxyDocument_ErrorCreatingService, ex); } return(ret); } }
/// <summary> /// Complete the proxy connection by passing back the token and getting a new IDataAdapter /// </summary> /// <param name="token">The token returned from client</param> /// <param name="globalMeta">Global meta object</param> /// <param name="meta">Meta object</param> /// <param name="service">The service which contains this server</param> /// <param name="client">The client adapter which was created</param> /// <returns>The final data adapter, should be used for further work</returns> public abstract IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client);
/// <summary> /// /// </summary> /// <param name="adapter"></param> /// <param name="meta"></param> /// <param name="globalMeta"></param> /// <param name="service"></param> /// <returns></returns> public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service) { ProxyToken token = null; if (_config.SslConfig.Enabled) { IDataAdapter client = null; INetworkLayer ssl = new SslNetworkLayer(_config.SslConfig); ssl.Negotiate(ref adapter, ref client, null, _logger, null, null, new PropertyBag("Root"), NetworkLayerBinding.Server); } if (adapter is HttpProxyDataAdapter) { HttpProxyDataAdapter proxyAdapter = (HttpProxyDataAdapter)adapter; token = new FullHttpProxyToken(proxyAdapter.Url.Host, proxyAdapter.Url.Port); token.State.Add("adapter", adapter); } else { DataAdapterToStream stm = new DataAdapterToStream(adapter); DataReader reader = new DataReader(stm); try { HttpRequestHeader header = HttpParser.ReadRequestHeader(reader, false, _logger); if (HandleProxyAuthentication(reader, stm, ref header)) { // We just have a connect if (header.IsConnect) { token = HandleConnect(header, stm); } else { token = HandleOtherRequest(header, stm, service); } } } catch (HttpStreamParserException ex) { _logger.LogError(CANAPE.Net.Properties.Resources.HttpProxyServer_InvalidRequest, ex.Message); // TODO: Put in some decent error codes ReturnResponse(null, 400, "Bad Request", "GET", HttpVersion.Version11, stm); } catch (EndOfStreamException) { token = null; } } return token; }
/// <summary> /// /// </summary> /// <param name="token"></param> /// <param name="meta"></param> /// <param name="globalMeta"></param> /// <param name="service"></param> /// <param name="client"></param> /// <returns></returns> public override IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client) { FixedProxyToken passToken = (FixedProxyToken)token; IDataAdapter adapter = passToken.Adapter; if (token.Status != NetStatusCodes.Success) { return(null); } else { // Set to null to prevent Dispose being called passToken.Adapter = null; return(adapter); } }
/// <summary> /// /// </summary> /// <param name="adapter"></param> /// <param name="globalMeta"></param> /// <param name="meta"></param> /// <param name="service"></param> /// <returns></returns> public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service) { HttpProxyToken token = null; if (_ssl != null) { IDataAdapter client = null; _ssl.Negotiate(ref adapter, ref client, null, _logger, null, null, new PropertyBag("Root"), NetworkLayerBinding.Server); } DataAdapterToStream stm = new DataAdapterToStream(adapter); List <string> headers = new List <string>(); // Read out HTTP headers try { while (true) { string nextLine = GeneralUtils.ReadLine(stm); headers.Add(nextLine); if (nextLine.Trim('\r', '\n').Length == 0) { break; } } } catch (EndOfStreamException) { // Pass on the exception if we got killed half way through if (headers.Count > 0) { throw; } } if (headers.Count > 0) { string[] reqValues = headers[0].Trim().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); // Check it at least has a VERB and a PATH if (reqValues.Length > 1) { if (reqValues[0].Equals("CONNECT", StringComparison.OrdinalIgnoreCase)) { token = HandleConnect(reqValues[1], headers.ToArray(), stm); } else { token = HandleOtherRequest(reqValues[1], headers.ToArray(), stm); } } else { _logger.LogError(CANAPE.Net.Properties.Resources.HttpProxyServer_InvalidRequest, headers[0]); // TODO: Put in some decent error codes ReturnResponse(500, "Server Error", stm); } } return(token); }
/// <summary> /// /// </summary> /// <param name="token"></param> /// <param name="client"></param> /// <param name="globalMeta"></param> /// <param name="meta"></param> /// <param name="service"></param> /// <returns></returns> public override IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client) { SocksProxyToken socksToken = (SocksProxyToken)token; if (IsSupported(socksToken.Version)) { if (socksToken.Version == 4) { return(HandleSocksV4Response(socksToken)); } else if (socksToken.Version == 5) { return(HandleSocksV5Response(socksToken)); } else { // We shouldn't get here throw new InvalidOperationException(CANAPE.Net.Properties.Resources.SocksProxyServer_IsSupportedError); } } else { _logger.LogError(CANAPE.Net.Properties.Resources.SocksProxyServer_UnsupportedTokenVersion, socksToken.Version); } return(null); }
/// <summary> /// /// </summary> /// <param name="token"></param> /// <param name="client"></param> /// <param name="globalMeta"></param> /// <param name="meta"></param> /// <param name="service"></param> /// <returns></returns> public override IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client) { IDataAdapter ret = null; HttpProxyToken httpToken = (HttpProxyToken)token; DataAdapterToStream stm = httpToken.Adapter; if (httpToken.Status == NetStatusCodes.Success) { if (httpToken.IsHTTPProxyClient) { // We don't have to do anything as such, other than send back any smuggled data if it was a connect call if (httpToken.Response != null) { stm.Write(httpToken.Response, 0, httpToken.Response.Length); } httpToken.Adapter = null; if (httpToken.Connect) { // With CONNECT the data stream is transparent ret = new StreamDataAdapter(stm); } else { // For anything else, rebuild the original headers so it can flow through the graph StringBuilder builder = new StringBuilder(); foreach (string s in httpToken.Headers) { builder.Append(s); } ret = new PrefixedDataAdapter(new StreamDataAdapter(stm), GeneralUtils.MakeByteArray(builder.ToString())); } } else { if (httpToken.Connect) { ReturnResponse(200, "Connection established", stm); httpToken.Adapter = null; ret = new StreamDataAdapter(stm); } else { StringBuilder builder = new StringBuilder(); string[] reqValues = httpToken.Headers[0].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); // Downgrade to version 1.0 httpToken.Headers[0] = reqValues[0] + " " + httpToken.Url.PathAndQuery + " HTTP/1.0\r\n"; foreach (string s in httpToken.Headers) { // Remove proxy headers if (!s.StartsWith("proxy", StringComparison.OrdinalIgnoreCase)) { builder.Append(s); } } httpToken.Adapter = null; ret = new PrefixedDataAdapter(new StreamDataAdapter(stm), GeneralUtils.MakeByteArray(builder.ToString())); } } } else { ReturnResponse(404, "Not Found", stm); } return(ret); }