private void SaveDataFrame(Http2Stream stream, DataFrame dataFrame)
{
lock (_writeLock)
{
string path = stream.Headers.GetValue(":path".ToLower());
try
{
string pathToSave = AssemblyPath + @"\Root" + path;
if (!Directory.Exists(Path.GetDirectoryName(pathToSave)))
{
throw new DirectoryNotFoundException("Access denied");
}
_fileHelper.SaveToFile(dataFrame.Data.Array, dataFrame.Data.Offset, dataFrame.Data.Count,
pathToSave, stream.ReceivedDataAmount != 0);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
stream.WriteDataFrame(new byte[0], true);
stream.Dispose();
}
stream.ReceivedDataAmount += dataFrame.FrameLength;
if (dataFrame.IsEndStream)
{
if (!stream.EndStreamSent)
{
//send terminator
stream.WriteDataFrame(new byte[0], true);
Console.WriteLine("Terminator was sent");
}
_fileHelper.RemoveStream(AssemblyPath + @"\Root" + path);
}
}
}
private void SaveDataFrame(Http2Stream stream, DataFrame dataFrame)
{
lock (_writeLock)
{
string originalPath = stream.Headers.GetValue(":path".ToLower());
//If user sets the empty file in get command we return notFound webpage
string fileName = string.IsNullOrEmpty(Path.GetFileName(originalPath)) ? Index : Path.GetFileName(originalPath);
string path = Path.Combine(AssemblyPath, fileName);
try
{
_fileHelper.SaveToFile(dataFrame.Data.Array, dataFrame.Data.Offset, dataFrame.Data.Count,
path, stream.ReceivedDataAmount != 0);
}
catch (IOException)
{
Http2Logger.LogError("File is still downloading. Repeat request later");
stream.WriteDataFrame(new byte[0], true);
stream.Dispose();
}
stream.ReceivedDataAmount += dataFrame.FrameLength;
if (dataFrame.IsEndStream)
{
if (!stream.EndStreamSent)
{
//send terminator
stream.WriteDataFrame(new byte[0], true);
Http2Logger.LogConsole("Terminator was sent");
}
_fileHelper.RemoveStream(path);
Http2Logger.LogConsole("Bytes received " + stream.ReceivedDataAmount);
#if DEBUG
const string wayToServerRoot1 = @"..\..\..\..\..\Drop\Root";
const string wayToServerRoot2 = @".\Root";
var areFilesEqual = _fileHelper.CompareFiles(path, wayToServerRoot1 + originalPath) ||
_fileHelper.CompareFiles(path, wayToServerRoot2 + originalPath);
if (!areFilesEqual)
{
Console.ForegroundColor = ConsoleColor.Red;
Http2Logger.LogError("Files are NOT EQUAL!");
}
else
{
Console.ForegroundColor = ConsoleColor.Green;
Http2Logger.LogConsole("Files are EQUAL!");
}
Console.ForegroundColor = ConsoleColor.Gray;
#endif
}
}
}
/// <summary>
/// Dispatches the incoming frame.
/// </summary>
/// <param name="frame">The frame.</param>
/// <exception cref="System.NotImplementedException"></exception>
private void DispatchIncomingFrame(Frame frame)
{
Http2Stream stream = null;
//Spec 03 tells that frame with continues flag MUST be followed by a frame with the same type
//and the same stread id.
if (_toBeContinuedHeaders != null)
{
if (_toBeContinuedFrame.FrameType != frame.FrameType
|| _toBeContinuedFrame.StreamId != frame.StreamId)
{
//If not, we must close the session.
Dispose();
return;
}
}
try
{
switch (frame.FrameType)
{
case FrameType.Headers:
Console.WriteLine("New headers with id = " + frame.StreamId);
var headersFrame = (Headers) frame;
var serializedHeaders = new byte[headersFrame.CompressedHeaders.Count];
Buffer.BlockCopy(headersFrame.CompressedHeaders.Array,
headersFrame.CompressedHeaders.Offset,
serializedHeaders, 0, serializedHeaders.Length);
var decompressedHeaders = _comprProc.Decompress(serializedHeaders, frame.StreamId % 2 != 0);
var headers = decompressedHeaders;
if (!headersFrame.IsEndHeaders)
{
_toBeContinuedHeaders = decompressedHeaders;
_toBeContinuedFrame = headersFrame;
break;
}
if (_toBeContinuedHeaders != null)
{
headers.AddRange(_toBeContinuedHeaders);
}
//Remote side tries to open more streams than allowed
if (ActiveStreams.GetOpenedStreamsBy(_remoteEnd) + 1 > OurMaxConcurrentStreams)
{
Dispose();
return;
}
string path;
try
{
path = headers.GetValue(":path");
}
catch (KeyNotFoundException)
{
path = !_handshakeHeaders.ContainsKey(":path") ? _handshakeHeaders[":path"] : @"\index.html";
headers.Add(new Tuple<string, string, IAdditionalHeaderInfo>(":path", path, null));
}
stream = new Http2Stream(headers, headersFrame.StreamId,
_writeQueue, _flowControlManager,
_comprProc);
ActiveStreams[stream.Id] = stream;
stream.OnClose += (o, args) =>
{
if (!ActiveStreams.Remove(ActiveStreams[args.Id]))
{
throw new ArgumentException("Cant remove stream from ActiveStreams");
}
};
_toBeContinuedFrame = null;
_toBeContinuedHeaders = null;
break;
case FrameType.Priority:
var priorityFrame = (PriorityFrame) frame;
stream = GetStream(priorityFrame.StreamId);
if (_usePriorities)
{
stream.Priority = priorityFrame.Priority;
}
break;
case FrameType.RstStream:
var resetFrame = (RstStreamFrame) frame;
stream = GetStream(resetFrame.StreamId);
Console.WriteLine("Got rst with code {0}", resetFrame.StatusCode);
stream.Dispose();
break;
case FrameType.Data:
var dataFrame = (DataFrame) frame;
stream = GetStream(dataFrame.StreamId);
//Aggressive window update
if (stream.IsFlowControlEnabled)
{
stream.WriteWindowUpdate(2000000);
}
break;
case FrameType.Ping:
var pingFrame = (PingFrame) frame;
if (pingFrame.IsPong)
{
_wasPingReceived = true;
_pingReceived.Set();
}
else
{
var pingResonseFrame = new PingFrame(true);
_writeQueue.WriteFrame(pingResonseFrame);
}
break;
case FrameType.Settings:
//Not first frame in the session.
//Client initiates connection and sends settings before request.
//It means that if server sent settings before it will not be a first frame,
//because client initiates connection.
if (_ourEnd == ConnectionEnd.Server && !_wasSettingsReceived && ActiveStreams.Count != 0)
{
Dispose();
return;
}
_wasSettingsReceived = true;
_settingsManager.ProcessSettings((SettingsFrame) frame, this, _flowControlManager);
break;
case FrameType.WindowUpdate:
if (_useFlowControl)
{
var windowFrame = (WindowUpdateFrame) frame;
stream = GetStream(windowFrame.StreamId);
stream.UpdateWindowSize(windowFrame.Delta);
stream.PumpUnshippedFrames();
}
break;
case FrameType.GoAway:
_goAwayReceived = true;
Dispose();
break;
default:
throw new NotImplementedException(frame.FrameType.ToString());
}
if (stream != null && frame is IEndStreamFrame && ((IEndStreamFrame)frame).IsEndStream)
{
//Tell the stream that it was the last frame
Console.WriteLine("Final frame received for stream with id = " + stream.Id);
stream.EndStreamReceived = true;
}
if (stream != null && OnFrameReceived != null)
{
OnFrameReceived(this, new FrameReceivedEventArgs(stream, frame));
}
}
//Frame came for already closed stream. Ignore it.
//Spec:
//An endpoint that sends RST_STREAM MUST ignore
//frames that it receives on closed streams if it sends RST_STREAM.
//
//An endpoint MUST NOT send frames on a closed stream. An endpoint
//that receives a frame after receiving a RST_STREAM or a frame
//containing a END_STREAM flag on that stream MUST treat that as a
//stream error (Section 5.4.2) of type PROTOCOL_ERROR.
catch (Http2StreamNotFoundException)
{
if (stream != null)
{
stream.WriteRst(ResetStatusCode.ProtocolError);
}
else
{
//GoAway?
}
}
}