protected override IEnumerable <DataFrame> GetFrames()
{
ProxyConnection conn = _conns.Dequeue();
while (conn != null)
{
bool receivedFinal = false;
foreach (HttpResponseDataChunk chunk in conn.ResponseReader)
{
receivedFinal = chunk.FinalChunk;
yield return(chunk.ToDataFrame());
}
// If we didn't receive final chunk we have an error, start shutdown
if (!receivedFinal)
{
_conns.Stop();
break;
}
conn = _conns.Dequeue();
}
lock (_graphs)
{
foreach (NetGraph graph in _graphs)
{
_service.CloseConnection(graph);
}
}
}
public static ProxyConnection CreateProxy(int serverID, byte[] connectMsg)
{
ProxyConnection conn = null;
try
{
//DebugWriteLine($"Attempting to create proxy for ServerID {serverID}...");
conn = new ProxyConnection(serverID, connectMsg, OnProxyClose);
//DebugWriteLine($"Created proxy connection for ServerID {serverID}!");
}
catch (SocksException ex)
{
//DebugWriteLine($"Failed to create ProxyConnection for ServerID {serverID}. Reason: {ex.Message} ({ex.ErrorCode})");
switch (ex.ErrorCode)
{
case SocksError.Disconnected:
new Thread(() => SendDisconnect(serverID)).Start();
break;
case SocksError.InvalidDatagram:
new Thread(() => SendDisconnect(serverID)).Start();
break;
default:
new Thread(() => SendError(serverID, ex.ErrorCode)).Start();
break;
}
}
catch (Exception ex)
{
//DebugWriteLine($"Unhandled exception while creating new proxy connection to ServerID {serverID}: {ex.Message}");
new Thread(() => SendDisconnect(serverID));
}
return(conn);
}
private static void DispatchDatagram(object dg)
{
SocksDatagram curMsg = (SocksDatagram)dg;
byte[] data;
try
{
data = Convert.FromBase64String(curMsg.data);
}
catch (Exception ex)
{
//DebugWriteLine($"Error decoding data: {ex.Message}");
return;
}
ProxyConnection conn = GetProxyConnection(curMsg.server_id);
if (conn == null)
{
if (curMsg.data != "LTE=")
{
CreateNewProxyConnection(curMsg.server_id, data);
}
}
else
{
conn.EnqueueRequestData(data);
}
}
private static void ProcessConnectionEvent(ConnectionTable connectionTable, ProxyConnection connection, string eventMessage)
{
var connections = connectionTable.ConnectionIndecies.Count;
var endPoint = (IPEndPoint)connection.Socket.RemoteEndPoint;
var target = connection.IsClient ? "client" : "telegram";
Log($"{endPoint.Address}:{endPoint.Port} ({target}) {eventMessage} ({connections} connections)");
}
public TcpConnectionHandler(Socket client)
{
Console.WriteLine("TcpHandlerConnection thread->" + Thread.CurrentThread.ManagedThreadId);
this.sObject = new StateObject(size: 512, client.RemoteEndPoint);
this.client = client;
proxy = new ProxyConnection(this);
BeginReceive();
}
public void TunnelTest()
{
var clientTcp = new TestTcpClient();
var connection = new ProxyConnection(clientTcp)
{
CreateTcpClientForServer = (host, port) => new TestTcpClient(host, port)
};
var exceptions = new List <Exception>();
connection.FatalException += (_, e) => exceptions.Add(e);
connection.StartReceiving();
var tcsSession = new TaskCompletionSource <IReadOnlySession>();
connection.HttpResponseSent += result => tcsSession.TrySetResult(result);
var request =
@"CONNECT www.example.com:443 HTTP/1.1
Host: www.example.com:443
Proxy-Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.79 Safari/537.36
";
clientTcp.WriteToInput(request);
var session = tcsSession.GetResult();
session.Request.ToString().Is(request);
var expectedResponse =
@"HTTP/1.1 200 Connection Established
Date: Mon, 01 Jan 2018 01:00:00 GMT
";
session.Response.ToString().Is(expectedResponse);
connection.serverConnection.client.AsTest().Host.Is("www.example.com");
connection.serverConnection.client.AsTest().Port.Is(443);
connection.serverConnection.IsTunnelMode.IsTrue();
connection.clientConnection.IsTunnelMode.IsTrue();
var expectedString = "hogehoge\r\n";
clientTcp.WriteToInput(expectedString);
// HTTP と解釈できないので例外が発生するが、データは送信されている。
var serverTcp = connection.serverConnection.client.AsTest();
serverTcp.GetStream().AsTest().OutputStream.Is(expectedString);
exceptions.Count.Is(1);
connection.Dispose();
}
public void Session302Test()
{
var clientTcp = new TestTcpClient();
var connection = new ProxyConnection(clientTcp)
{
CreateTcpClientForServer = (host, port) => new TestTcpClient(host, port)
};
connection.StartReceiving();
var tcsRequest = new TaskCompletionSource <IReadOnlyHttpRequest>();
connection.HttpRequestSent += result => tcsRequest.TrySetResult(result);
var tcsSession = new TaskCompletionSource <IReadOnlySession>();
connection.HttpResponseSent += result => tcsSession.TrySetResult(result);
var tcsClose = new TaskCompletionSource <ProxyConnection>();
connection.Disposing += result => tcsClose.TrySetResult(result);
var request =
@"GET http://www.example.com/netgame/social/-/gadgets/=/app_id=854854/ HTTP/1.1
Host: www.example.com
Proxy-Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.79 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
";
clientTcp.WriteToInput(request);
var requestResult = tcsRequest.GetResult();
connection.serverConnection.client.AsTest().WriteFileToInput("TestData/Response302");
var sessionResult = tcsSession.GetResult();
sessionResult.Request.ToString().Is(request);
var response = sessionResult.Response as HttpResponse;
response.GetBodyAsString().Is("");
connection.serverConnection.client.AsTest().Close(); // サーバーから閉じる
//clientTcp.Close(); // クライアントから閉じる
tcsClose.GetResult().Is(connection);
connection.Dispose();
}
private async Task ListenToConnection()
{
while (_isRunning)
{
var client = await _listener.AcceptTcpClientAsync();
var connection = new ProxyConnection(this, client, _to);
_connections.Add(connection);
connection.Transfer();
}
}
public static void AddProxy(ProxyConnection conn)
{
if (conn == null)
{
return;
}
//proxyConnectionMapMtx.WaitOne();
proxyConnectionMap[conn.ServerID] = conn;
//DebugWriteLine($"ProxyConnectionMap Count: {proxyConnectionMap.Count}");
//proxyConnectionMapMtx.ReleaseMutex();
}
//public static void AwaitConnectionDisconnect(ProxyConnection conn)
//{
// if (conn == null)
// return;
// conn.ExitEvent.WaitOne();
// var msg = new SocksDatagram()
// {
// server_id = conn.ServerID,
// data = Convert.ToBase64String(DisconnectMessageBytes)
// };
// AddMythicMessageToQueue(msg);
//}
//public static void AwaitRemoveConnection(ProxyConnection conn)
//{
// if (conn == null)
// return;
// conn.ExitEvent.WaitOne();
// //DebugWriteLine("Attempting to remove proxy!");
// RemoveProxyConnection(conn.ServerID);
//}
public static void CreateNewProxyConnection(int serverID, byte[] dg)
{
ProxyConnection conn = CreateProxy(serverID, dg);
if (conn != null)
{
AddProxy(conn);
conn.StartRelay();
var msgToSend = CreateFormattedMessageWithLength(SocksError.SuccessReply, conn);
AddMythicMessageToQueue(msgToSend);
}
}
public void PerformTest()
{
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <ProxyConnection> mockProxyConnection = new Mock <ProxyConnection>(It.IsAny <ProxyHost>(), It.IsAny <ProxyInfo>(), It.IsAny <TcpClient>());
EventInfo eventInfo = mockEventInfo.Object;
ProxyConnection proxyConnection = mockProxyConnection.Object;
var testCases = new[]
{
new
{
EventType = EventType.Connected,
SendDataCalled = false,
ExpectedThenResponse = ThenResponse.Continue
},
new
{
EventType = EventType.Disconnected,
SendDataCalled = false,
ExpectedThenResponse = ThenResponse.Continue
},
new
{
EventType = EventType.Message,
SendDataCalled = true,
ExpectedThenResponse = ThenResponse.Continue
}
};
foreach (var testCase in testCases)
{
ThenSendData then = new ThenSendData();
mockEventInfo.Reset();
mockProxyConnection.Reset();
mockEventInfo.Setup(mock => mock.ProxyConnection).Returns(proxyConnection);
mockEventInfo.Setup(mock => mock.Type).Returns(testCase.EventType);
Assert.AreEqual(testCase.ExpectedThenResponse, then.Perform(eventInfo));
if (testCase.SendDataCalled)
{
mockProxyConnection.Verify(mock => mock.SendData(eventInfo), Times.Once);
}
else
{
mockProxyConnection.Verify(mock => mock.SendData(It.IsAny <EventInfo>()), Times.Never);
}
}
}
public void SessionNoBodyTest()
{
var clientTcp = new TestTcpClient();
var connection = new ProxyConnection(clientTcp)
{
CreateTcpClientForServer = (host, port) => new TestTcpClient(host, port)
};
connection.StartReceiving();
var tcsRequest = new TaskCompletionSource <IReadOnlyHttpRequest>();
connection.HttpRequestSent += result => tcsRequest.TrySetResult(result);
var tcsSession = new TaskCompletionSource <IReadOnlySession>();
connection.HttpResponseSent += result => tcsSession.TrySetResult(result);
var tcsClose = new TaskCompletionSource <ProxyConnection>();
connection.Disposing += result => tcsClose.TrySetResult(result);
var request =
@"GET http://203.104.209.71/kcs2/resources/voice/titlecall_1/005.mp3 HTTP/1.1
Host: 203.104.209.71
";
clientTcp.WriteToInput(request);
var requestResult = tcsRequest.GetResult();
connection.serverConnection.client.AsTest().WriteFileToInput("TestData/ResponseNoBody");
var sessionResult = tcsSession.GetResult();
sessionResult.Request.ToString().Is(request);
var response = sessionResult.Response as HttpResponse;
response.GetBodyAsString().Is("");
connection.serverConnection.client.AsTest().Close(); // サーバーから閉じる
//clientTcp.Close(); // クライアントから閉じる
tcsClose.GetResult().Is(connection);
connection.Dispose();
}
public Entity.ProxyConnection GetOneConnection(Guid id)
{
CacheHelper.ClearCache();
ProxyConnection conn = null;
//using (Xrm.XrmServiceContext context = new Xrm.XrmServiceContext("Xrm"))
//{
Xrm.Connection c = this.xrm.ConnectionSet.Where(i => i.Id == id).FirstOrDefault();
if (c != null)
{
conn = ObjectConverter.SingleConvertToProxyConnection(c, this.xrm);
}
//}
return(conn);
}
public static ProxyConnection GetProxyConnection(int channelID)
{
ProxyConnection result = null;
////DebugWriteLine("Requesting proxyConnectionMapMtx.");
//proxyConnectionMapMtx.WaitOne();
//DebugWriteLine($"Attempting to fetch connection with Channel ID: {channelID}...");
if (proxyConnectionMap.TryGetValue(channelID, out result))
{
//DebugWriteLine($"Fetched connection with Channel ID: {channelID}!");
return(result);
}
else
{
//DebugWriteLine($"Failed fetch connection with Channel ID: {channelID}.");
return(null);
}
}
private void Poll()
{
while (polling)
{
try {
if (!listener.Pending())
{
Thread.Sleep(500);
continue;
}
Socket socket = listener.AcceptSocket();
ProxyConnection conn = new ProxyConnection(this);
ThreadPool.QueueUserWorkItem(conn.Process, socket);
} catch (Exception e) {
Logger.Warning("Socket Error while processing a proxy connection.", e);
}
}
}
public void WhenHasEntity_IsMatch_AlwaysTrue()
{
List <MessageValue> alwaysTrueMessageValues = new List <MessageValue>()
{
MessageValue.DataDirection,
MessageValue.LocalAddress,
MessageValue.LocalPort,
MessageValue.Protocol,
MessageValue.SourceRemoteAddress,
MessageValue.SourceRemotePort
};
IEnumerable <MessageValue> notAlwaysTrueMessageValues = Enum.GetValues(typeof(MessageValue)).Cast <MessageValue>().Except(alwaysTrueMessageValues);
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <ProxyConnection> mockProxyConnection = new Mock <ProxyConnection>(It.IsAny <ProxyHost>(), It.IsAny <ProxyInfo>(), It.IsAny <TcpClient>());
Mock <ProxyInfo> mockProxyInfo = new Mock <ProxyInfo>();
EventInfo eventInfo = mockEventInfo.Object;
ProxyConnection proxyConnection = mockProxyConnection.Object;
ProxyInfo proxyInfo = mockProxyInfo.Object;
mockEventInfo.Setup(mock => mock.ProxyConnection).Returns(proxyConnection);
mockProxyConnection.Setup(mock => mock.ProxyInfo).Returns(proxyInfo);
WhenHasEntity when = new WhenHasEntity();
foreach (MessageValue value in alwaysTrueMessageValues)
{
when.MessageValue = value;
Assert.IsTrue(when.IsMatch(eventInfo));
}
foreach (MessageValue value in notAlwaysTrueMessageValues)
{
when.MessageValue = value;
Assert.IsFalse(when.IsMatch(eventInfo));
}
}
private void OnConnected(IAsyncResult result)
{
try
{
TelegramSocket.EndConnect(result);
if (!TelegramSocket.Connected)
{
Connection.Close();
return;
}
TelegramSocket.Blocking = false;
var telegramConnection = new ProxyConnection(TelegramSocket, Connection);
var encryptor = new Cryptography.MTProtoCryptor(Buffer, false);
var decryptor = new Cryptography.MTProtoCryptor(Buffer, true);
var tmp = new byte[Buffer.Length];
encryptor.Transform(Buffer, 0, Buffer.Length, tmp, 0);
for (var i = 0; i < 56; i++)
{
tmp[i] = Buffer[i];
}
telegramConnection.Send(tmp, 0, tmp.Length);
telegramConnection.Encryptor = encryptor;
telegramConnection.Decryptor = decryptor;
Connection.ReverseConnection = telegramConnection;
Connection.DataHandler = new ProxyHandler(Connection);
Connection.AssignedTabled.Register(telegramConnection);
}
catch
{
Connection.Close();
}
}
public void WhenHasEntity_IsMatch_DestinationRemotePortTest()
{
WhenHasEntity when = new WhenHasEntity()
{
MessageValue = MessageValue.DestinationRemotePort
};
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <ProxyConnection> mockProxyConnection = new Mock <ProxyConnection>(It.IsAny <ProxyHost>(), It.IsAny <ProxyInfo>(), It.IsAny <TcpClient>());
EventInfo eventInfo = mockEventInfo.Object;
ProxyConnection proxyConnection = mockProxyConnection.Object;
mockEventInfo.Setup(mock => mock.ProxyConnection).Returns(proxyConnection);
mockProxyConnection.Setup(mock => mock.HasTargetConnection).Returns(true);
Assert.IsTrue(when.IsMatch(eventInfo));
mockProxyConnection.Reset();
mockProxyConnection.Setup(mock => mock.HasTargetConnection).Returns(false);
Assert.IsFalse(when.IsMatch(eventInfo));
}
public CryptoSetupHandler(ProxyConnection connection)
{
Connection = connection;
}
public virtual EventInfo Clone(RulesEngine engine = null, EventType?type = null, DataDirection?direction = null, Message message = null, ProxyConnection proxyConnection = null, Variables variables = null)
{
return(new EventInfo()
{
Engine = engine ?? Engine,
Type = type ?? Type,
Direction = direction ?? Direction,
Message = message ?? Message,
ProxyConnection = proxyConnection ?? ProxyConnection,
Variables = variables ?? Variables
});
}
public void UpdateOneConnection(ProxyConnection c)
{
}
public void ThenAddMessage_PerformTest()
{
string messageText = "blah blah blah";
Variables toTargetVariables = new Variables();
Variables toOriginVariables = new Variables();
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>()
{
CallBase = true
};
Mock <ProxyConnection> mockProxyConnection = new Mock <ProxyConnection>(It.IsAny <ProxyHost>(), It.IsAny <ProxyInfo>(), It.IsAny <TcpClient>());
Mock <VariableString> mockMessageTextString = new Mock <VariableString>(It.IsAny <string>(), null);
Mock <RulesEngine> mockRulesEngine = new Mock <RulesEngine>()
{
CallBase = true
};
Mock <MessageQueue <EventInfo> > mockMessageQueue = new Mock <MessageQueue <EventInfo> >();
EventInfo eventInfo = mockEventInfo.Object;
VariableString messageTextString = mockMessageTextString.Object;
RulesEngine rulesEngine = mockRulesEngine.Object;
MessageQueue <EventInfo> messageQueue = mockMessageQueue.Object;
ProxyConnection proxyConnection = mockProxyConnection.Object;
mockMessageTextString.Setup(mock => mock.GetText(It.IsAny <Variables>())).Returns(messageText);
mockProxyConnection.Setup(mock => mock.ToTargetConnectionVariables).Returns(toTargetVariables);
mockProxyConnection.Setup(mock => mock.ToOriginConnectionVariables).Returns(toOriginVariables);
mockRulesEngine.Setup(mock => mock.Queue).Returns(messageQueue);
mockEventInfo.Setup(mock => mock.Engine).Returns(rulesEngine);
mockEventInfo.Setup(mock => mock.ProxyConnection).Returns(proxyConnection);
var testCases = new[]
{
new
{
Direction = DataDirection.Origin,
InsertAtBeginning = true,
ExpectedVariables = toOriginVariables
},
new
{
Direction = DataDirection.Origin,
InsertAtBeginning = false,
ExpectedVariables = toOriginVariables
},
new
{
Direction = DataDirection.Target,
InsertAtBeginning = true,
ExpectedVariables = toTargetVariables
},
new
{
Direction = DataDirection.Target,
InsertAtBeginning = false,
ExpectedVariables = toTargetVariables
}
};
foreach (var testCase in testCases)
{
ThenAddMessage then = new ThenAddMessage()
{
Direction = testCase.Direction,
InsertAtBeginning = testCase.InsertAtBeginning,
MessageText = messageTextString
};
mockMessageQueue.Reset();
if (testCase.InsertAtBeginning)
{
mockMessageQueue.Setup(mock => mock.AddFirst(It.IsAny <EventInfo>())).Callback((EventInfo eventInfoParam) =>
{
Assert.AreEqual(testCase.ExpectedVariables, eventInfoParam.Variables);
Assert.AreEqual(messageText, eventInfoParam.Message.RawText);
});
Assert.AreEqual(ThenResponse.Continue, then.Perform(eventInfo));
mockMessageQueue.Verify(mock => mock.AddFirst(It.IsAny <EventInfo>()), Times.Once);
}
else
{
mockMessageQueue.Setup(mock => mock.AddLast(It.IsAny <EventInfo>())).Callback((EventInfo eventInfoParam) =>
{
Assert.AreEqual(testCase.ExpectedVariables, eventInfoParam.Variables);
Assert.AreEqual(messageText, eventInfoParam.Message.RawText);
});
Assert.AreEqual(ThenResponse.Continue, then.Perform(eventInfo));
mockMessageQueue.Verify(mock => mock.AddLast(It.IsAny <EventInfo>()), Times.Once);
}
}
}
public void WhenMatchesText_IsMatch_MessageValue_WithIdentifierTests()
{
string sourceString = "TestString";
string identifier = "Ident";
List <MessageValue> testableValues = new List <MessageValue>
{
MessageValue.HttpHeader
};
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <ProxyInfo> mockProxyInfo = new Mock <ProxyInfo>();
Mock <ProxyConnection> mockProxyConnection = new Mock <ProxyConnection>(It.IsAny <ProxyHost>(), It.IsAny <ProxyInfo>(), It.IsAny <TcpClient>());
Mock <HttpMessage> mockHttpMessage = new Mock <HttpMessage>();
Mock <HttpHeaders> mockHttpHeaders = new Mock <HttpHeaders>();
Mock <VariableString> mockIdentiferString = new Mock <VariableString>(It.IsAny <string>(), null);
EventInfo eventInfo = mockEventInfo.Object;
ProxyConnection proxyConnection = mockProxyConnection.Object;
ProxyInfo proxyInfo = mockProxyInfo.Object;
HttpMessage httpMessage = mockHttpMessage.Object;
HttpHeaders httpHeaders = mockHttpHeaders.Object;
VariableString identiferString = mockIdentiferString.Object;
mockEventInfo.Setup(mock => mock.ProxyConnection).Returns(proxyConnection);
mockEventInfo.Setup(mock => mock.Message).Returns(httpMessage);
mockProxyConnection.Setup(mock => mock.ProxyInfo).Returns(proxyInfo);
mockHttpHeaders.Setup(mock => mock.GetOrDefault(identifier)).Returns(sourceString);
mockIdentiferString.Setup(mock => mock.GetText(It.IsAny <Variables>())).Returns(identifier);
var testCases = new[]
{
new
{
MatchString = GetMockVariableString("Test"),
MatchType = MatchType.BeginsWith,
Matches = true
},
new
{
MatchString = GetMockVariableString("est"),
MatchType = MatchType.Contains,
Matches = true
},
new
{
MatchString = GetMockVariableString("ing"),
MatchType = MatchType.EndsWith,
Matches = true
},
new
{
MatchString = GetMockVariableString("TestString"),
MatchType = MatchType.Equals,
Matches = true
},
new
{
MatchString = GetMockVariableString(".*Str.*"),
MatchType = MatchType.Regex,
Matches = true
},
new
{
MatchString = GetMockVariableString("MatchString"),
MatchType = MatchType.BeginsWith,
Matches = false
},
new
{
MatchString = GetMockVariableString("MatchString"),
MatchType = MatchType.Contains,
Matches = false
},
new
{
MatchString = GetMockVariableString("MatchString"),
MatchType = MatchType.EndsWith,
Matches = false
},
new
{
MatchString = GetMockVariableString("MatchString"),
MatchType = MatchType.Equals,
Matches = false
},
new
{
MatchString = GetMockVariableString("MatchString"),
MatchType = MatchType.Regex,
Matches = false
}
};
foreach (MessageValue messageValue in testableValues)
{
mockHttpMessage.Reset();
mockHttpMessage.Setup(mock => mock.Headers).Returns(httpHeaders);
foreach (var testCase in testCases)
{
WhenMatchesText when = new WhenMatchesText()
{
MessageValue = messageValue,
UseMessageValue = true,
MatchText = testCase.MatchString,
MatchType = testCase.MatchType,
Identifier = identiferString
};
Assert.AreEqual(testCase.Matches, when.IsMatch(eventInfo));
}
}
}
private void Poll()
{
while (polling) {
try {
if (!listener.Pending()) {
Thread.Sleep(500);
continue;
}
Socket socket = listener.AcceptSocket();
ProxyConnection conn = new ProxyConnection(this);
ThreadPool.QueueUserWorkItem(conn.Process, socket);
} catch(Exception e) {
Logger.Warning("Socket Error while processing a proxy connection.", e);
}
}
}
public void WhenMatchesText_IsMatch_MessageValue_IntTests()
{
int sourceValue = 40494;
List <MessageValue> testableValues = new List <MessageValue>
{
MessageValue.DestinationRemotePort,
MessageValue.SourceRemotePort,
MessageValue.LocalPort,
MessageValue.HttpStatusCode
};
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <HttpMessage> mockHttpMessage = new Mock <HttpMessage>();
Mock <ProxyConnection> mockProxyConnection = new Mock <ProxyConnection>(It.IsAny <ProxyHost>(), It.IsAny <ProxyInfo>(), It.IsAny <TcpClient>());
Mock <ProxyInfo> mockProxyInfo = new Mock <ProxyInfo>();
Mock <Channel> mockChannel = new Mock <Channel>(It.IsAny <TcpClient>());
Mock <IPEndPoint> mockIPEndPoint = new Mock <IPEndPoint>(It.IsAny <long>(), It.IsAny <int>());
Mock <IPAddress> mockIPAddress = new Mock <IPAddress>(It.IsAny <long>());
Mock <HttpResponseStatusLine> mockHttpResponseStatusLine = new Mock <HttpResponseStatusLine>();
EventInfo eventInfo = mockEventInfo.Object;
ProxyConnection proxyConnection = mockProxyConnection.Object;
ProxyInfo proxyInfo = mockProxyInfo.Object;
HttpMessage httpMessage = mockHttpMessage.Object;
HttpResponseStatusLine responseStatusLine = mockHttpResponseStatusLine.Object;
Channel channel = mockChannel.Object;
IPEndPoint ipEndpoint = mockIPEndPoint.Object;
IPAddress ipAddress = mockIPAddress.Object;
mockEventInfo.Setup(mock => mock.ProxyConnection).Returns(proxyConnection);
mockEventInfo.Setup(mock => mock.Message).Returns(httpMessage);
mockProxyConnection.Setup(mock => mock.HasTargetConnection).Returns(true);
mockProxyConnection.Setup(mock => mock.OriginChannel).Returns(channel);
mockProxyConnection.Setup(mock => mock.TargetChannel).Returns(channel);
mockProxyConnection.Setup(mock => mock.ProxyInfo).Returns(proxyInfo);
mockChannel.Setup(mock => mock.LocalEndpoint).Returns(ipEndpoint);
mockChannel.Setup(mock => mock.RemoteEndpoint).Returns(ipEndpoint);
mockHttpMessage.Setup(mock => mock.StatusLine).Returns(responseStatusLine);
ipEndpoint.Port = sourceValue;
mockHttpResponseStatusLine.Setup(mock => mock.StatusCode).Returns(sourceValue);
var testCases = new[]
{
new
{
MatchString = GetMockVariableString("40"),
MatchType = MatchType.BeginsWith,
Matches = true
},
new
{
MatchString = GetMockVariableString("49"),
MatchType = MatchType.Contains,
Matches = true
},
new
{
MatchString = GetMockVariableString("94"),
MatchType = MatchType.EndsWith,
Matches = true
},
new
{
MatchString = GetMockVariableString("40494"),
MatchType = MatchType.Equals,
Matches = true
},
new
{
MatchString = GetMockVariableString(".*49.*"),
MatchType = MatchType.Regex,
Matches = true
},
new
{
MatchString = GetMockVariableString("65"),
MatchType = MatchType.BeginsWith,
Matches = false
},
new
{
MatchString = GetMockVariableString("65"),
MatchType = MatchType.Contains,
Matches = false
},
new
{
MatchString = GetMockVariableString("65"),
MatchType = MatchType.EndsWith,
Matches = false
},
new
{
MatchString = GetMockVariableString("65"),
MatchType = MatchType.Equals,
Matches = false
},
new
{
MatchString = GetMockVariableString("65"),
MatchType = MatchType.Regex,
Matches = false
}
};
foreach (MessageValue messageValue in testableValues)
{
foreach (var testCase in testCases)
{
WhenMatchesText when = new WhenMatchesText()
{
MessageValue = messageValue,
UseMessageValue = true,
MatchText = testCase.MatchString,
MatchType = testCase.MatchType
};
Assert.AreEqual(testCase.Matches, when.IsMatch(eventInfo));
}
}
}
public void WhenMatchesText_IsMatch_MessageValue_SimpleStringTests()
{
string sourceString = "TestString";
List <MessageValue> testableValues = new List <MessageValue>
{
MessageValue.DestinationRemoteAddress,
MessageValue.HttpMethod,
MessageValue.HttpRequestUri,
MessageValue.LocalAddress,
MessageValue.Protocol,
MessageValue.SourceRemoteAddress,
MessageValue.HttpBody,
MessageValue.Message,
MessageValue.HttpHeaders,
MessageValue.HttpStatusLine,
MessageValue.HttpVersion,
MessageValue.HttpStatusMessage
};
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <ProxyInfo> mockProxyInfo = new Mock <ProxyInfo>();
Mock <ProxyConnection> mockProxyConnection = new Mock <ProxyConnection>(It.IsAny <ProxyHost>(), It.IsAny <ProxyInfo>(), It.IsAny <TcpClient>());
Mock <HttpMessage> mockHttpMessage = new Mock <HttpMessage>();
Mock <HttpResponseStatusLine> mockHttpResponseStatusLine = new Mock <HttpResponseStatusLine>();
Mock <HttpRequestStatusLine> mockHttpRequestStatusLine = new Mock <HttpRequestStatusLine>();
Mock <HttpBody> mockHttpBody = new Mock <HttpBody>();
Mock <HttpHeaders> mockHttpHeaders = new Mock <HttpHeaders>();
Mock <Channel> mockChannel = new Mock <Channel>(It.IsAny <TcpClient>());
Mock <IPEndPoint> mockIPEndPoint = new Mock <IPEndPoint>(It.IsAny <long>(), It.IsAny <int>());
Mock <IPAddress> mockIPAddress = new Mock <IPAddress>(It.IsAny <long>());
EventInfo eventInfo = mockEventInfo.Object;
ProxyConnection proxyConnection = mockProxyConnection.Object;
ProxyInfo proxyInfo = mockProxyInfo.Object;
HttpMessage httpMessage = mockHttpMessage.Object;
HttpResponseStatusLine responseStatusLine = mockHttpResponseStatusLine.Object;
HttpRequestStatusLine requestStatusLine = mockHttpRequestStatusLine.Object;
HttpBody httpBody = mockHttpBody.Object;
HttpHeaders httpHeaders = mockHttpHeaders.Object;
Channel channel = mockChannel.Object;
IPEndPoint ipEndpoint = mockIPEndPoint.Object;
IPAddress ipAddress = mockIPAddress.Object;
mockEventInfo.Setup(mock => mock.ProxyConnection).Returns(proxyConnection);
mockEventInfo.Setup(mock => mock.Message).Returns(httpMessage);
mockProxyConnection.Setup(mock => mock.HasTargetConnection).Returns(true);
mockProxyConnection.Setup(mock => mock.HasOriginConnection).Returns(true);
mockProxyConnection.Setup(mock => mock.OriginChannel).Returns(channel);
mockProxyConnection.Setup(mock => mock.TargetChannel).Returns(channel);
mockProxyConnection.Setup(mock => mock.ProxyInfo).Returns(proxyInfo);
mockChannel.Setup(mock => mock.LocalEndpoint).Returns(ipEndpoint);
mockChannel.Setup(mock => mock.RemoteEndpoint).Returns(ipEndpoint);
ipEndpoint.Address = ipAddress;
mockHttpHeaders.Setup(mock => mock.ToString()).Returns(sourceString);
mockHttpBody.Setup(mock => mock.ToString()).Returns(sourceString);
mockIPAddress.Setup(mock => mock.ToString()).Returns(sourceString);
mockHttpResponseStatusLine.Setup(mock => mock.ToString()).Returns(sourceString);
mockHttpResponseStatusLine.Setup(mock => mock.StatusMessage).Returns(sourceString);
mockHttpResponseStatusLine.Setup(mock => mock.Version).Returns(sourceString);
mockHttpRequestStatusLine.Setup(mock => mock.ToString()).Returns(sourceString);
mockHttpRequestStatusLine.Setup(mock => mock.Method).Returns(sourceString);
mockHttpRequestStatusLine.Setup(mock => mock.Uri).Returns(sourceString);
mockHttpRequestStatusLine.Setup(mock => mock.Version).Returns(sourceString);
var testCases = new[]
{
new
{
MatchString = GetMockVariableString("Test"),
MatchType = MatchType.BeginsWith,
Matches = true
},
new
{
MatchString = GetMockVariableString("est"),
MatchType = MatchType.Contains,
Matches = true
},
new
{
MatchString = GetMockVariableString("ing"),
MatchType = MatchType.EndsWith,
Matches = true
},
new
{
MatchString = GetMockVariableString("TestString"),
MatchType = MatchType.Equals,
Matches = true
},
new
{
MatchString = GetMockVariableString(".*Str.*"),
MatchType = MatchType.Regex,
Matches = true
},
new
{
MatchString = GetMockVariableString("MatchString"),
MatchType = MatchType.BeginsWith,
Matches = false
},
new
{
MatchString = GetMockVariableString("MatchString"),
MatchType = MatchType.Contains,
Matches = false
},
new
{
MatchString = GetMockVariableString("MatchString"),
MatchType = MatchType.EndsWith,
Matches = false
},
new
{
MatchString = GetMockVariableString("MatchString"),
MatchType = MatchType.Equals,
Matches = false
},
new
{
MatchString = GetMockVariableString("MatchString"),
MatchType = MatchType.Regex,
Matches = false
}
};
foreach (MessageValue messageValue in testableValues)
{
mockHttpMessage.Reset();
switch (messageValue)
{
case MessageValue.HttpStatusLine:
case MessageValue.HttpVersion:
case MessageValue.HttpStatusMessage:
mockHttpMessage.Setup(mock => mock.Body).Returns(httpBody);
mockHttpMessage.Setup(mock => mock.Headers).Returns(httpHeaders);
mockHttpMessage.Setup(mock => mock.RawText).Returns(sourceString);
mockHttpMessage.Setup(mock => mock.Protocol).Returns(sourceString);
mockHttpMessage.Setup(mock => mock.ToString()).Returns(sourceString);
mockHttpMessage.Setup(mock => mock.StatusLine).Returns(responseStatusLine);
break;
default:
mockHttpMessage.Setup(mock => mock.Body).Returns(httpBody);
mockHttpMessage.Setup(mock => mock.Headers).Returns(httpHeaders);
mockHttpMessage.Setup(mock => mock.RawText).Returns(sourceString);
mockHttpMessage.Setup(mock => mock.Protocol).Returns(sourceString);
mockHttpMessage.Setup(mock => mock.ToString()).Returns(sourceString);
mockHttpMessage.Setup(mock => mock.StatusLine).Returns(requestStatusLine);
break;
}
foreach (var testCase in testCases)
{
WhenMatchesText when = new WhenMatchesText()
{
MessageValue = messageValue,
UseMessageValue = true,
MatchText = testCase.MatchString,
MatchType = testCase.MatchType
};
Assert.AreEqual(testCase.Matches, when.IsMatch(eventInfo));
}
}
}
private static void Connections_OnConnectionRegistered(ConnectionTable connectionTable, ProxyConnection connection)
{
ProcessConnectionEvent(connectionTable, connection, "connected");
}
public void ThenHttpConnect_PerformTest()
{
string hostname = "www.google.com";
int port = 90;
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <ProxyConnection> mockProxyConnection = new Mock <ProxyConnection>(It.IsAny <ProxyHost>(), It.IsAny <ProxyInfo>(), It.IsAny <TcpClient>());
Mock <HttpMessage> mockHttpMessage = new Mock <HttpMessage>();
Mock <HttpHeaders> mockHttpHeaders = new Mock <HttpHeaders>();
EventInfo eventInfo = mockEventInfo.Object;
ProxyConnection proxyConnection = mockProxyConnection.Object;
HttpMessage httpMessage = mockHttpMessage.Object;
HttpHeaders httpHeaders = mockHttpHeaders.Object;
mockHttpMessage.SetupGet(mock => mock.Headers).Returns(httpHeaders);
var testCases = new[]
{
new
{
HasTargetConnection = false,
DataDirection = DataDirection.Target,
OverrideCurrentConnection = false,
HeaderValue = (string)null,
InitTargetChannelSuccess = false,
InitTargetChannelCalled = false,
ExpectedThenResponse = ThenResponse.BreakRules,
ExpectedHostname = (string)null,
ExpectedPort = (int?)null
},
new
{
HasTargetConnection = true,
DataDirection = DataDirection.Target,
OverrideCurrentConnection = true,
HeaderValue = $"{hostname}:{port}",
InitTargetChannelSuccess = true,
InitTargetChannelCalled = true,
ExpectedThenResponse = ThenResponse.Continue,
ExpectedHostname = hostname,
ExpectedPort = (int?)port
},
new
{
HasTargetConnection = false,
DataDirection = DataDirection.Target,
OverrideCurrentConnection = false,
HeaderValue = $"{hostname}:{port}",
InitTargetChannelSuccess = true,
InitTargetChannelCalled = true,
ExpectedThenResponse = ThenResponse.Continue,
ExpectedHostname = hostname,
ExpectedPort = (int?)port
},
new
{
HasTargetConnection = false,
DataDirection = DataDirection.Target,
OverrideCurrentConnection = false,
HeaderValue = $"{hostname}",
InitTargetChannelSuccess = true,
InitTargetChannelCalled = true,
ExpectedThenResponse = ThenResponse.Continue,
ExpectedHostname = hostname,
ExpectedPort = (int?)80
},
new
{
HasTargetConnection = false,
DataDirection = DataDirection.Target,
OverrideCurrentConnection = false,
HeaderValue = $"{hostname}:{port}",
InitTargetChannelSuccess = false,
InitTargetChannelCalled = true,
ExpectedThenResponse = ThenResponse.BreakRules,
ExpectedHostname = hostname,
ExpectedPort = (int?)port
}
};
foreach (var testCase in testCases)
{
ThenHttpConnect then = new ThenHttpConnect();
mockEventInfo.Reset();
mockProxyConnection.Reset();
mockHttpHeaders.Reset();
mockEventInfo.Setup(mock => mock.ProxyConnection).Returns(proxyConnection);
mockEventInfo.Setup(mock => mock.Direction).Returns(testCase.DataDirection);
mockEventInfo.Setup(mock => mock.Message).Returns(httpMessage);
mockHttpHeaders.Setup(mock => mock.GetOrDefault("Host")).Returns(testCase.HeaderValue);
mockProxyConnection.Setup(mock => mock.HasTargetConnection).Returns(testCase.HasTargetConnection);
if (testCase.InitTargetChannelCalled)
{
then.OverrideCurrentConnection = testCase.OverrideCurrentConnection;
mockProxyConnection.Setup(mock => mock.InitConnection(It.IsAny <DataDirection>(), It.IsAny <string>(), It.IsAny <int>())).Returns(testCase.InitTargetChannelSuccess);
Assert.AreEqual(testCase.ExpectedThenResponse, then.Perform(eventInfo));
mockProxyConnection.Verify(mock => mock.InitConnection(testCase.DataDirection, testCase.ExpectedHostname, testCase.ExpectedPort.GetValueOrDefault()), Times.Once);
}
else
{
then.OverrideCurrentConnection = testCase.OverrideCurrentConnection;
Assert.AreEqual(testCase.ExpectedThenResponse, then.Perform(eventInfo));
mockProxyConnection.Verify(mock => mock.InitConnection(It.IsAny <DataDirection>(), It.IsAny <string>(), It.IsAny <int>()), Times.Never);
}
}
}
public void SessionContentLengthTest()
{
var clientTcp = new TestTcpClient();
var connection = new ProxyConnection(clientTcp)
{
CreateTcpClientForServer = (host, port) => new TestTcpClient(host, port)
};
connection.StartReceiving();
var tcsRequest = new TaskCompletionSource <IReadOnlyHttpRequest>();
connection.HttpRequestSent += result => tcsRequest.TrySetResult(result);
var tcsSession = new TaskCompletionSource <IReadOnlySession>();
connection.HttpResponseSent += result => tcsSession.TrySetResult(result);
var tcsClose = new TaskCompletionSource <ProxyConnection>();
connection.Disposing += result => tcsClose.TrySetResult(result);
var request =
@"GET http://203.104.209.71/kcs2/resources/voice/titlecall_1/005.mp3 HTTP/1.1
Host: 203.104.209.71
Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.79 Safari/537.36
Accept: */*
Referer: http://203.104.209.71/kcs2/index.php?api_root=/kcsapi&voice_root=/kcs/sound&osapi_root=osapi.example.com&version=4.1.1.4
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
";
clientTcp.WriteToInput(request);
//var tcsRequestSuccess = tcsRequest.Task.Wait(1000);
//if (!tcsRequestSuccess)
// Assert.False(true, "request timeout");
var requestResult = tcsRequest.GetResult();
connection.serverConnection.client.AsTest().WriteFileToInput("TestData/ResponseContentLength");
//var tcsSessionSuccess = tcsSession.Task.Wait(1000);
//if (!tcsSessionSuccess)
// Assert.False(true, "session timeout");
var sessionResult = tcsSession.GetResult();
var requestHeaders = sessionResult.Request.Headers as HttpHeaders;
sessionResult.Request.RequestLine.HttpVersion.Is(new Version(1, 1));
sessionResult.Request.RequestLine.Method.Is(HttpMethod.Get);
sessionResult.Request.RequestLine.RequestTarget.Is("http://203.104.209.71/kcs2/resources/voice/titlecall_1/005.mp3");
requestHeaders.Host.Is("203.104.209.71");
requestHeaders.GetFirstValue("Connection").Is("keep-alive");
requestHeaders.GetFirstValue("User-Agent").Is("Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.79 Safari/537.36");
requestHeaders.GetFirstValue("Accept").Is("*/*");
requestHeaders.GetFirstValue("Referer").Is("http://203.104.209.71/kcs2/index.php?api_root=/kcsapi&voice_root=/kcs/sound&osapi_root=osapi.example.com&version=4.1.1.4");
requestHeaders.GetFirstValue("Accept-Encoding").Is("gzip, deflate");
requestHeaders.GetFirstValue("Accept-Language").Is("en-US,en;q=0.9");
requestHeaders.HasHeader("Via").IsFalse();
sessionResult.Request.Body.IsNull();
var response = sessionResult.Response as HttpResponse;
response.StatusLine.HttpVersion.Is(new Version(1, 1));
response.StatusLine.StatusCode.Is(HttpStatusCode.OK);
response.StatusLine.ReasonPhrase.Is("OK");
response.Headers.ContentLength.Exists.Is(true);
response.Headers.ContentLength.Is(47);
response.Headers.TransferEncoding.Exists.Is(false);
response.Headers.IsChunked.Is(false);
response.Headers.GetFirstValue("Access-Control-Allow-Credentials").Is("true");
response.Headers.GetFirstValue("Access-Control-Allow-Methods").Is("POST,GET,HEAD,OPTIONS");
response.Headers.GetFirstValue("Access-Control-Allow-Origin").Is("http://d.hatena.ne.jp");
response.Headers.GetFirstValue("Cache-Control").Is("no-store, no-cache");
response.Headers.ContentType.Is("application/json");
response.Headers.GetFirstValue("Date").Is("Thu, 20 Sep 2018 01:59:09 GMT");
response.Headers.GetFirstValue("Expires").Is("Mon, 15 Jun 1998 00:00:00 GMT");
response.Headers.GetFirstValue("Pragma").Is("no-cache");
response.Headers.GetFirstValue("Server").Is("Adtech Adserver");
response.GetBodyAsString().Is(@"{""id"":""31259257328373081"",""seatbid"":[],""nbr"":1}");
//connection.serverConnection.client.AsTest().Close(); // サーバーから閉じる
clientTcp.Close(); // クライアントから閉じる
tcsClose.GetResult().Is(connection);
connection.Dispose();
}
public TamperClient(TamperServer server, TcpClient tcpClient)
{
parent = server;
ProxyConnection = new ProxyConnection(tcpClient);
ProxyConnection.Interceptor = this;
}
private IEnumerable<HttpResponseDataChunk> GetResponse(ProxyConnection conn, Uri url, bool headRequest)
{
try
{
DataReader reader = new DataReader(conn.DataAdapter.Coupling);
HttpParserConfig config = new HttpParserConfig();
config.StreamBody = true;
if (_server._config.Version10Proxy)
{
config.DowngradeChunkedToHttp10 = true;
}
_logger.LogVerbose("Starting processing of {0}", url);
HttpResponseHeader response = HttpParser.ReadResponseHeader(reader, false, _logger);
// If 100 continue then read out just that response then restart read
if (response.Is100Continue)
{
foreach (HttpResponseDataChunk chunk in response.ReadChunks(config))
{
_logger.LogVerbose("Read 100 continue chunk for {0} {1} {2}", url, chunk.Body.Length, chunk.FinalChunk);
yield return chunk;
}
response = HttpParser.ReadResponseHeader(reader, false, _logger);
}
_logger.LogVerbose("Read response header {0}", response.ResponseCode);
response.SetHeadRequest(headRequest);
foreach (HttpResponseDataChunk newChunk in response.ReadChunks(config))
{
_logger.LogVerbose("Read chunk for {0} {1} {2}", url, newChunk.Body.Length, newChunk.FinalChunk);
yield return newChunk;
}
}
finally
{
bool closeSuccess = false;
try
{
conn.DataAdapter.Coupling.Close();
lock (_graphs)
{
_graphs.Remove(conn.Graph);
}
closeSuccess = true;
}
catch (OperationCanceledException)
{
}
catch (ObjectDisposedException)
{
}
if (!closeSuccess)
{
lock (_graphs)
{
// Force close
_service.CloseConnection(conn.Graph);
_graphs.Remove(conn.Graph);
}
}
}
}
public void WhenProxyType_IsMatchTest()
{
var testCases = new[]
{
new
{
InputEventInfo = ((Func <EventInfo>)(() =>
{
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <ProxyConnection> mockProxyConnection = new Mock <ProxyConnection>(It.IsAny <ProxyHost>(), It.IsAny <ProxyInfo>(), It.IsAny <TcpClient>());
Mock <ProxyInfo> mockProxyInfo = new Mock <ProxyInfo>();
EventInfo eventInfo = mockEventInfo.Object;
ProxyConnection proxyConnection = mockProxyConnection.Object;
ProxyInfo proxyInfo = mockProxyInfo.Object;
mockEventInfo.Setup(mock => mock.ProxyConnection).Returns(proxyConnection);
mockProxyConnection.SetupGet(mock => mock.ProxyInfo).Returns(proxyInfo);
mockProxyInfo.SetupGet(mock => mock.DataType).Returns(ProxyDataType.Http);
return(eventInfo);
})).Invoke(),
Type = ProxyDataType.Http,
WillMatch = true
},
new
{
InputEventInfo = ((Func <EventInfo>)(() =>
{
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <ProxyConnection> mockProxyConnection = new Mock <ProxyConnection>(It.IsAny <ProxyHost>(), It.IsAny <ProxyInfo>(), It.IsAny <TcpClient>());
Mock <ProxyInfo> mockProxyInfo = new Mock <ProxyInfo>();
EventInfo eventInfo = mockEventInfo.Object;
ProxyConnection proxyConnection = mockProxyConnection.Object;
ProxyInfo proxyInfo = mockProxyInfo.Object;
mockEventInfo.Setup(mock => mock.ProxyConnection).Returns(proxyConnection);
mockProxyConnection.SetupGet(mock => mock.ProxyInfo).Returns(proxyInfo);
mockProxyInfo.SetupGet(mock => mock.DataType).Returns(ProxyDataType.Text);
return(eventInfo);
})).Invoke(),
Type = ProxyDataType.Text,
WillMatch = true
},
new
{
InputEventInfo = ((Func <EventInfo>)(() =>
{
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <ProxyConnection> mockProxyConnection = new Mock <ProxyConnection>(It.IsAny <ProxyHost>(), It.IsAny <ProxyInfo>(), It.IsAny <TcpClient>());
Mock <ProxyInfo> mockProxyInfo = new Mock <ProxyInfo>();
EventInfo eventInfo = mockEventInfo.Object;
ProxyConnection proxyConnection = mockProxyConnection.Object;
ProxyInfo proxyInfo = mockProxyInfo.Object;
mockEventInfo.Setup(mock => mock.ProxyConnection).Returns(proxyConnection);
mockProxyConnection.SetupGet(mock => mock.ProxyInfo).Returns(proxyInfo);
mockProxyInfo.SetupGet(mock => mock.DataType).Returns(ProxyDataType.Http);
return(eventInfo);
})).Invoke(),
Type = ProxyDataType.Text,
WillMatch = false
},
new
{
InputEventInfo = ((Func <EventInfo>)(() =>
{
Mock <EventInfo> mockEventInfo = new Mock <EventInfo>();
Mock <ProxyConnection> mockProxyConnection = new Mock <ProxyConnection>(It.IsAny <ProxyHost>(), It.IsAny <ProxyInfo>(), It.IsAny <TcpClient>());
Mock <ProxyInfo> mockProxyInfo = new Mock <ProxyInfo>();
EventInfo eventInfo = mockEventInfo.Object;
ProxyConnection proxyConnection = mockProxyConnection.Object;
ProxyInfo proxyInfo = mockProxyInfo.Object;
mockEventInfo.Setup(mock => mock.ProxyConnection).Returns(proxyConnection);
mockProxyConnection.SetupGet(mock => mock.ProxyInfo).Returns(proxyInfo);
mockProxyInfo.SetupGet(mock => mock.DataType).Returns(ProxyDataType.Text);
return(eventInfo);
})).Invoke(),
Type = ProxyDataType.Http,
WillMatch = false
}
};
foreach (var testCase in testCases)
{
WhenProxyType when = new WhenProxyType()
{
ProxyType = testCase.Type
};
Assert.AreEqual(testCase.WillMatch, when.IsMatch(testCase.InputEventInfo));
}
}
public override void Write(DataFrame frame)
{
Uri currUri = null;
HttpRequestDataChunk chunk = frame.Root.GetValue(DATA_NAME).Value;
if (chunk.ChunkNumber == 0)
{
int error = 0;
string message = null;
if (_currOutConn == null)
{
try
{
_logger.LogVerbose("Received new connection to {0}", chunk.Path);
currUri = new Uri(chunk.Path, UriKind.Absolute);
chunk.Path = currUri.PathAndQuery;
// Upgrade to at least version 1.0
if (chunk.Version.IsVersionUnknown)
{
chunk.Version = HttpVersion.Version10;
}
// Add a Connection: close header?
_currOutConn = new ProxyConnection();
_currOutConn.DataAdapter = new HttpProxyDataAdapter(currUri, _cancellationSource.Token);
_currOutConn.Graph = ConnectClient(_currOutConn.DataAdapter);
if (_currOutConn.Graph == null)
{
_currOutConn.DataAdapter.Close();
error = 404;
message = "Not Found";
_currOutConn = null;
}
else
{
_currOutConn.ResponseReader = GetResponse(_currOutConn, currUri, chunk.Method.Equals("HEAD", StringComparison.OrdinalIgnoreCase));
_conns.Enqueue(_currOutConn);
}
}
catch (UriFormatException)
{
error = 400;
message = "Bad Request";
}
if (error != 0)
{
ProxyConnection conn = new ProxyConnection();
conn.ResponseReader = new[] { BuildError(error, message, chunk.Method, chunk.Version) };
_conns.Enqueue(conn);
}
}
}
if (_currOutConn != null)
{
DataWriter writer = new DataWriter(new DataAdapterToStream(_currOutConn.DataAdapter.Coupling));
chunk.WriteChunk(writer);
if (chunk.FinalChunk)
{
_currOutConn = null;
}
}
else
{
// Do nothing
}
}
