/// <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);
}
