public void HttpParsingMultipeRequestsTest()
{
const string HttpString = "GET /url1 HTTP/1.1\r\n" +
"A: B\r\n" +
"B: C\r\n" +
"\r\n" +
"GET /url2 HTTP/1.1\r\n" +
"C: D\r\n" +
"D: E\r\n" +
"\r\n";
Packet packet = BuildPacket(HttpString);
var https = packet.Ethernet.IpV4.Tcp.HttpCollection;
Assert.AreEqual(2, https.Count);
foreach (HttpDatagram http in https)
{
Assert.IsTrue(http.IsRequest);
Assert.IsFalse(http.IsResponse);
Assert.AreEqual(HttpVersion.Version11, http.Version);
Assert.AreEqual(Datagram.Empty, http.Body);
}
HttpRequestDatagram request = (HttpRequestDatagram)https[0];
Assert.AreEqual(new HttpRequestMethod(HttpRequestKnownMethod.Get), request.Method);
Assert.AreEqual("/url1", request.Uri);
Assert.AreEqual(new HttpHeader(HttpField.CreateField("A", "B"), HttpField.CreateField("B", "C")), request.Header);
request = (HttpRequestDatagram)https[1];
Assert.AreEqual(new HttpRequestMethod(HttpRequestKnownMethod.Get), request.Method);
Assert.AreEqual("/url2", request.Uri);
Assert.AreEqual(new HttpHeader(HttpField.CreateField("C", "D"), HttpField.CreateField("D", "E")), request.Header);
}
private static void TestHttpRequest(string httpString, string expectedMethodString = null, string expectedUri = null, HttpVersion expectedVersion = null, HttpHeader expectedHeader = null, string expectedBodyString = null)
{
Datagram expectedBody = expectedBodyString == null ? null : new Datagram(Encoding.ASCII.GetBytes(expectedBodyString));
HttpRequestMethod expectedMethod = expectedMethodString == null ? null : new HttpRequestMethod(expectedMethodString);
Packet packet = BuildPacket(httpString);
// HTTP
HttpDatagram http = packet.Ethernet.IpV4.Tcp.Http;
Assert.IsTrue(http.IsRequest, "IsRequest " + httpString);
Assert.IsFalse(http.IsResponse, "IsResponse " + httpString);
Assert.AreEqual(expectedVersion, http.Version, "Version " + httpString);
Assert.AreEqual(expectedHeader, http.Header, "Header " + httpString);
if (expectedHeader != null)
{
Assert.AreEqual(expectedHeader.ToString(), http.Header.ToString(), "Header " + httpString);
}
HttpRequestDatagram request = (HttpRequestDatagram)http;
Assert.AreEqual(expectedMethod, request.Method, "Method " + httpString);
Assert.AreEqual(expectedUri, request.Uri, "Uri " + httpString);
Assert.AreEqual(expectedBody, request.Body, "Body " + httpString);
}
public void ReadDumpFile(string path)
{
// Opens device
OfflinePacketDevice device = new OfflinePacketDevice(path);
using (PacketCommunicator communicator = device.Open(0x10000, PacketDeviceOpenAttributes.Promiscuous, 1000))
{
//communicator.SetFilter("ip and tcp");
//communicator.ReceivePackets(0, DispatcherHandler);
Packet packet;
communicator.ReceivePacket(out packet);
while (packet != null)
{
if (IsHttpRequest(packet))
{
HttpRequestDatagram request = packet?.Ethernet?.Ip?.Tcp?.Http as HttpRequestDatagram;
ParseHttpRequest(request);
}
// Gets next packet
communicator.ReceivePacket(out packet);
}
}
}
private void ParseHttpRequest(HttpRequestDatagram request)
{
if (request.Uri == null || request.Header == null)
{
return;
}
FileRequest fileRequest;
if (request.Uri.Contains('?'))
{
string[] pathQuery = request.Uri.Split('?');
fileRequest = CreateRequest(request.Header["Host"].ValueString, pathQuery[0], pathQuery[1]);
}
else
{
fileRequest = CreateRequest(request.Header["Host"].ValueString, request.Uri, "");
}
// Downloads file
string localPath = GetLocalPath(fileRequest, this.OutputDirectory);
if (!File.Exists(localPath))
{
DownloadFile(fileRequest.FullRequest, localPath);
}
UpdateManifest();
}
private void ProcessPacket(Packet packet)
{
if (packet == null || !IsHttpRequest(packet))
{
return;
}
HttpRequestDatagram request = packet?.Ethernet?.Ip?.Tcp?.Http as HttpRequestDatagram;
ParseHttpRequest(request);
}
private static bool IsBadHttp(HttpDatagram httpDatagram)
{
if (httpDatagram.IsResponse)
{
HttpResponseDatagram httpResponseDatagram = (HttpResponseDatagram)httpDatagram;
if (httpResponseDatagram.StatusCode == null)
{
Assert.IsNull(httpResponseDatagram.Header);
return(true);
}
}
else
{
HttpRequestDatagram httpRequestDatagram = (HttpRequestDatagram)httpDatagram;
if (httpRequestDatagram.Version == null)
{
return(true);
}
}
return(false);
}
public void RandomHttpTest()
{
int seed = new Random().Next();
Console.WriteLine("Seed: " + seed);
Random random = new Random(seed);
for (int i = 0; i != 200; ++i)
{
EthernetLayer ethernetLayer = random.NextEthernetLayer(EthernetType.None);
IpV4Layer ipV4Layer = random.NextIpV4Layer(null);
ipV4Layer.HeaderChecksum = null;
Layer ipLayer = random.NextBool() ? (Layer)ipV4Layer : random.NextIpV6Layer(true);
TcpLayer tcpLayer = random.NextTcpLayer();
tcpLayer.Checksum = null;
HttpLayer httpLayer = random.NextHttpLayer();
Packet packet = PacketBuilder.Build(DateTime.Now, ethernetLayer, ipLayer, tcpLayer, httpLayer);
Assert.IsTrue(packet.IsValid, "IsValid");
HttpDatagram httpDatagram = packet.Ethernet.Ip.Tcp.Http;
Assert.AreEqual(httpLayer.Version, httpDatagram.Version);
if (httpLayer.Version != null)
{
Assert.AreEqual(httpLayer.Version.GetHashCode(), httpDatagram.Version.GetHashCode());
}
if (httpLayer is HttpRequestLayer)
{
Assert.IsTrue(httpDatagram.IsRequest);
Assert.IsTrue(httpLayer.IsRequest);
Assert.IsFalse(httpDatagram.IsResponse);
Assert.IsFalse(httpLayer.IsResponse);
HttpRequestLayer httpRequestLayer = (HttpRequestLayer)httpLayer;
HttpRequestDatagram httpRequestDatagram = (HttpRequestDatagram)httpDatagram;
Assert.AreEqual(httpRequestLayer.Method, httpRequestDatagram.Method);
if (httpRequestLayer.Method != null)
{
Assert.AreEqual(httpRequestLayer.Method.GetHashCode(), httpRequestDatagram.Method.GetHashCode());
Assert.AreEqual(httpRequestLayer.Method.KnownMethod, httpRequestDatagram.Method.KnownMethod);
}
Assert.AreEqual(httpRequestLayer.Uri, httpRequestDatagram.Uri);
}
else
{
Assert.IsFalse(httpDatagram.IsRequest);
Assert.IsFalse(httpLayer.IsRequest);
Assert.IsTrue(httpDatagram.IsResponse);
Assert.IsTrue(httpLayer.IsResponse);
HttpResponseLayer httpResponseLayer = (HttpResponseLayer)httpLayer;
HttpResponseDatagram httpResponseDatagram = (HttpResponseDatagram)httpDatagram;
Assert.AreEqual(httpResponseLayer.StatusCode, httpResponseDatagram.StatusCode);
Assert.AreEqual(httpResponseLayer.ReasonPhrase, httpResponseDatagram.ReasonPhrase);
}
Assert.AreEqual(httpLayer.Header, httpDatagram.Header);
if (httpLayer.Header != null)
{
Assert.AreEqual(httpLayer.Header.GetHashCode(), httpDatagram.Header.GetHashCode());
if (!httpDatagram.IsRequest || ((HttpRequestDatagram)httpDatagram).Uri != "")
{
Assert.IsTrue(httpDatagram.IsValidStart, "IsValidStart");
}
foreach (var field in httpLayer.Header)
{
Assert.IsFalse(field.Equals("abc"));
}
foreach (var field in (IEnumerable)httpLayer.Header)
{
Assert.IsFalse(field.Equals("abc"));
}
MoreAssert.AreSequenceEqual(httpLayer.Header.Select(field => field.GetHashCode()), httpDatagram.Header.Select(field => field.GetHashCode()));
if (httpLayer.Header.ContentType != null)
{
var parameters = httpLayer.Header.ContentType.Parameters;
Assert.IsNotNull(((IEnumerable)parameters).GetEnumerator());
Assert.AreEqual <object>(parameters, httpDatagram.Header.ContentType.Parameters);
Assert.AreEqual(parameters.GetHashCode(), httpDatagram.Header.ContentType.Parameters.GetHashCode());
Assert.AreEqual(parameters.Count, httpDatagram.Header.ContentType.Parameters.Count);
int maxParameterNameLength = parameters.Any() ? parameters.Max(pair => pair.Key.Length) : 0;
Assert.IsNull(parameters[new string('a', maxParameterNameLength + 1)]);
}
}
Assert.AreEqual(httpLayer.Body, httpDatagram.Body);
Assert.AreEqual(httpLayer, httpDatagram.ExtractLayer(), "HTTP Layer");
Assert.AreEqual(httpLayer.Length, httpDatagram.Length);
}
}
private bool IsHttpRequest(Packet packet)
{
HttpRequestDatagram request = packet?.Ethernet?.Ip?.Tcp?.Http as HttpRequestDatagram;
return(request != null);
}
