/// <summary>
/// Get files via http request. Public interface to call for top file of the tree
/// </summary>
/// <param name="uri">The address site.</param>
/// <returns>New traffic log.</returns>
public HttpTrafficLog GetFile(string uri)
{
this.httpMonitor.LogTitle = "HTTP " + Path.GetFileName(uri);
// top level download is in main thread context
// because we parse HTML to get list of other files to download
string type = ContentTypes.GetTypeFromFileName(uri);
Uri requestUri = new Uri(uri);
byte[] content = this.Get(requestUri);
this.PrivateGetFile(content, type, requestUri, uri);
// give some time to name list to spin up
Thread.Sleep(50);
// wait for name monitor to finish
ThreadPool.QueueUserWorkItem(new WaitCallback(this.NameListMonitorProc), 0);
this.nameMonitorEvent.WaitOne(600000);
// wait for downloads to finish
WaitHandle.WaitAll(this.loaderEvents);
return(this.httpMonitor);
}
public static void Http11SendResponse(SecureSocket socket)
{
string[] headers = GetHttp11Headers(socket);
string filename = GetFileName(headers);
if (headers.Length == 0)
{
Http2Logger.LogError("Request headers empty!");
}
string path = Path.GetFullPath(AssemblyPath + @"\root" + filename);
string contentType = ContentTypes.GetTypeFromFileName(filename);
if (!File.Exists(path))
{
Http2Logger.LogError("File " + filename + " not found");
SendResponse(socket, new byte[0], StatusCode.Code404NotFound, contentType);
socket.Close();
return;
}
try
{
using (var sr = new StreamReader(path))
{
string file = sr.ReadToEnd();
var fileBytes = Encoding.UTF8.GetBytes(file);
int sent = SendResponse(socket, fileBytes, StatusCode.Code200Ok, contentType);
Http2Logger.LogDebug(string.Format("Sent: {0} bytes", sent));
Http2Logger.LogInfo("File sent: " + filename);
socket.Close();
if (OnSocketClosed != null)
{
OnSocketClosed(null, new SocketCloseEventArgs());
}
}
}
catch (Exception ex)
{
var msgBytes = Encoding.UTF8.GetBytes(ex.Message);
SendResponse(socket, msgBytes, StatusCode.Code500InternalServerError, contentType);
Http2Logger.LogError(ex.Message);
}
}
/// <summary>
/// Open of stream and sent request for receive data.
/// </summary>
/// <param name="fileName">Path to the data on server.</param>
/// <param name="session">Current session.</param>
/// <param name="isFin">Flag fin.</param>
/// <returns>New SMstream.</returns>
private static SMStream DownloadPathForList(string fileName, ref SMSession session, bool isFin)
{
if (session.State == SMSessionState.Opened)
{
SMHeaders headers = new SMHeaders();
headers[SMHeaders.Path] = fileName;
headers[SMHeaders.Version] = "http/1.1";
headers[SMHeaders.Method] = "GET";
headers[SMHeaders.Scheme] = "http";
headers[SMHeaders.ContentType] = ContentTypes.GetTypeFromFileName(fileName);
return(session.OpenStream(headers, isFin));
}
return(null);
}
public static string ConstructHeaders(Uri uri)
{
string requestHeaders = string.Format(
"GET {2} HTTP/1.1\r\n"
+ "Host: {0}:{1}\r\n"
+ "Connection: Keep-Alive\r\n"
+ "User-Agent: Http2Client\r\n"
+ "Accept: {3},application/xml;q=0.9,*/*;q=0.8\r\n"
+ "\r\n",
uri.Host,
uri.Port,
uri.AbsolutePath, // match what Chrome has in GET request
ContentTypes.GetTypeFromFileName(uri.ToString()));
return(requestHeaders);
}
/// <summary>
/// Thread proc for name list monitor
/// </summary>
/// <param name="stateInfo">RequestPackage for the thread</param>
private void NameListMonitorProc(object stateInfo)
{
while (true)
{
string name = this.GetNameToDownload();
if (name == string.Empty)
{
// done downloading
this.nameMonitorEvent.Set();
return;
}
bool found = false;
int currentThread = 0;
while (found == false)
{
// get first available thread
for (int i = 0; i < MaxLoaderThreads; i++)
{
if (this.getFilesPackages[i].Processed == 1)
{
currentThread = i;
found = true;
break;
}
}
if (found == false)
{
// wait a bit before trying again
Thread.Sleep(100);
}
}
// start downloading
Uri requestUri = new Uri(name);
this.getFilesPackages[currentThread].Type = ContentTypes.GetTypeFromFileName(name);
this.getFilesPackages[currentThread].RequestUri = requestUri;
this.getFilesPackages[currentThread].Name = name;
this.getFilesPackages[currentThread].LoaderEvent = this.loaderEvents[currentThread];
this.getFilesPackages[currentThread].LoaderEvent.Reset();
this.getFilesPackages[currentThread].Processed = 0;
ThreadPool.QueueUserWorkItem(new WaitCallback(this.HttpLoaderProc), this.getFilesPackages[currentThread]);
}
}
/// <summary>
/// Get files via URI.
/// </summary>
/// <param name="uri">The URI.</param>
/// <returns>File as byte array.</returns>
private byte[] Get(Uri uri)
{
using (TcpClient tcpClient = new TcpClient())
{
tcpClient.Connect(uri.Host, uri.Port);
var streamHttp = tcpClient.GetStream();
Stream stream = null;
if (uri.Scheme.Equals("http"))
{
stream = tcpClient.GetStream();
}
else
{
stream = new SslStream(streamHttp, false, null, null);
if (!AuthenticateAsClient(uri, (SslStream)stream))
{
tcpClient.Close();
return(null);
}
}
string headers;
if (useHttp2Handshake)
{
headers = string.Format(
"GET {2} HTTP/1.1\r\n"
+ "Host: {0}:{1}\r\n"
+ "Connection: Upgrade\r\n"
+ "User-Agent: SMClient\r\n"
+ "Upgrade: HTTP/2.0\r\n",
uri.Host,
uri.Port,
uri);
}
else
{
headers = string.Format(
"GET {2} HTTP/1.1\r\n"
+ "Host: {0}:{1}\r\n"
+ "Connection: Keep-Alive\r\n"
+ "User-Agent: SMClient\r\n"
+ "Accept: {3},application/xml;q=0.9,*/*;q=0.8\r\n",
uri.Host,
uri.Port,
uri,
ContentTypes.GetTypeFromFileName(uri.ToString()));
}
byte[] headersBytes = Encoding.UTF8.GetBytes(headers + "\r\n");
this.httpMonitor.LogRequest(headersBytes);
stream.Write(headersBytes, 0, headersBytes.Length);
int totalCount = 0;
byte[] inbuffer = new byte[BufferSize];
int max = 12;
if (this.serverLatency > 200)
{
max += (this.serverLatency - 200) / 14;
}
do
{
int c = stream.Read(inbuffer, totalCount, inbuffer.Length - totalCount);
if (c <= 0)
{
break;
}
totalCount += c;
// speed up sync socket
int i = 0;
for (i = 0; i < max; i++)
{
if (tcpClient.Available > 0)
{
break;
}
Thread.Sleep(40);
}
}while (tcpClient.Available > 0);
byte[] result = new byte[totalCount];
Buffer.BlockCopy(inbuffer, 0, result, 0, totalCount);
return(result);
}
}
/// <summary>
/// Get files via URI.
/// </summary>
/// <param name="uri">The URI.</param>
/// <returns>File as byte array.</returns>
private byte[] Get(Uri uri)
{
using (TcpClient tcpClient = new TcpClient())
{
var connectResult = tcpClient.BeginConnect(uri.Host, uri.Port, null, null);
bool success = connectResult.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(5), true);
if (success)
{
tcpClient.EndConnect(connectResult);
}
else
{
tcpClient.Close();
throw new SocketException(10060); // Connection timed out.
}
var streamHttp = tcpClient.GetStream();
Stream stream = null;
if (uri.Scheme.Equals("http"))
{
stream = tcpClient.GetStream();
}
else
{
stream = new SslStream(streamHttp, false, null, null);
if (!AuthenticateAsClient(uri, (SslStream)stream))
{
tcpClient.Close();
return(null);
}
}
string headers;
if (useHttp2Handshake)
{
headers = string.Format(
"GET {2} HTTP/1.1\r\n"
+ "Host: {0}:{1}\r\n"
+ "Connection: Upgrade\r\n"
+ "User-Agent: Http2Client\r\n"
+ "Upgrade: HTTP/2.0\r\n",
uri.Host,
uri.Port,
uri.AbsolutePath); // match what Chrome has in GET request
Http2Logger.LogDebug(headers);
}
else
{
headers = string.Format(
"GET {2} HTTP/1.1\r\n"
+ "Host: {0}:{1}\r\n"
+ "Connection: Keep-Alive\r\n"
+ "User-Agent: Http2Client\r\n"
+ "Accept: {3},application/xml;q=0.9,*/*;q=0.8\r\n",
uri.Host,
uri.Port,
uri.AbsolutePath, // match what Chrome has in GET request
ContentTypes.GetTypeFromFileName(uri.ToString()));
}
byte[] headersBytes = Encoding.UTF8.GetBytes(headers + "\r\n");
this.httpMonitor.LogRequest(headersBytes);
stream.Write(headersBytes, 0, headersBytes.Length);
int totalCount = 0;
byte[] inbuffer = new byte[BufferSize];
int max = 12;
if (this.serverLatency > 200)
{
max += (this.serverLatency - 200) / 14;
}
do
{
var readResult = stream.BeginRead(inbuffer, totalCount, inbuffer.Length - totalCount, null, null);
success = readResult.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(5), true);
if (!success)
{
break;
}
int c = stream.EndRead(readResult);
totalCount += c;
// speed up sync socket
int i = 0;
for (i = 0; i < max; i++)
{
if (tcpClient.Available > 0)
{
break;
}
Thread.Sleep(40);
}
}while (tcpClient.Available > 0);
byte[] result = new byte[totalCount];
Buffer.BlockCopy(inbuffer, 0, result, 0, totalCount);
return(result);
}
}
