public override async Task <PrimarySignature> GetPrimarySignatureAsync(CancellationToken token)
{
token.ThrowIfCancellationRequested();
if (ZipReadStream == null)
{
throw new SignatureException(Strings.SignedPackageUnableToAccessSignature);
}
PrimarySignature signature = null;
if (await IsSignedAsync(token))
{
using (var bufferedStream = new ReadOnlyBufferedStream(ZipReadStream, leaveOpen: true))
using (var reader = new BinaryReader(bufferedStream, new UTF8Encoding(), leaveOpen: true))
using (var stream = SignedPackageArchiveUtility.OpenPackageSignatureFileStream(reader))
{
#if IS_DESKTOP
signature = PrimarySignature.Load(stream);
#endif
}
}
return(signature);
}
public override async Task ValidateIntegrityAsync(SignatureContent signatureContent, CancellationToken token)
{
token.ThrowIfCancellationRequested();
if (signatureContent == null)
{
throw new ArgumentNullException(nameof(signatureContent));
}
if (ZipReadStream == null)
{
throw new SignatureException(Strings.SignedPackageUnableToAccessSignature);
}
if (!await IsSignedAsync(token))
{
throw new SignatureException(Strings.SignedPackageNotSignedOnVerify);
}
#if IS_DESKTOP
using (var bufferedStream = new ReadOnlyBufferedStream(ZipReadStream, leaveOpen: true))
using (var reader = new BinaryReader(bufferedStream, new UTF8Encoding(), leaveOpen: true))
using (var hashAlgorithm = signatureContent.HashAlgorithm.GetHashProvider())
{
var expectedHash = Convert.FromBase64String(signatureContent.HashValue);
if (!SignedPackageArchiveUtility.VerifySignedPackageIntegrity(reader, hashAlgorithm, expectedHash))
{
throw new SignatureException(NuGetLogCode.NU3008, Strings.SignaturePackageIntegrityFailure, GetIdentity());
}
}
#endif
}
private string GetContentHashForSignedPackage(CancellationToken token)
{
token.ThrowIfCancellationRequested();
if (ZipReadStream == null)
{
return(null);
}
using (var zip = new ZipArchive(ZipReadStream, ZipArchiveMode.Read, leaveOpen: true))
{
var signatureEntry = zip.GetEntry(SigningSpecifications.SignaturePath);
if (signatureEntry == null ||
!string.Equals(signatureEntry.Name, SigningSpecifications.SignaturePath, StringComparison.Ordinal))
{
return(null);
}
}
using (var bufferedStream = new ReadOnlyBufferedStream(ZipReadStream, leaveOpen: true))
using (var reader = new BinaryReader(bufferedStream, new UTF8Encoding(), leaveOpen: true))
{
return(SignedPackageArchiveUtility.GetPackageContentHash(reader));
}
}
public override async Task <PrimarySignature> GetPrimarySignatureAsync(CancellationToken token)
{
token.ThrowIfCancellationRequested();
ThrowIfZipReadStreamIsNull();
PrimarySignature signature = null;
if (await IsSignedAsync(token))
{
using (var bufferedStream = new ReadOnlyBufferedStream(ZipReadStream, leaveOpen: true))
using (var reader = new BinaryReader(bufferedStream, new UTF8Encoding(), leaveOpen: true))
using (var stream = SignedPackageArchiveUtility.OpenPackageSignatureFileStream(reader))
{
#if IS_SIGNING_SUPPORTED
signature = PrimarySignature.Load(stream);
#endif
}
}
return(signature);
}
public BufferedReadNetworkStream(Stream stream, int bufferSize)
{
this.innerStream = stream;
this.readStream = new ReadOnlyBufferedStream(stream, bufferSize);
}
private void ReceiveThreadFunc()
{
try
{
using (var bufferedStream = new ReadOnlyBufferedStream(this.Stream))
{
while (!closed)
{
try
{
WebSocketFrameReader frame = new WebSocketFrameReader();
frame.Read(bufferedStream);
lastMessage = DateTime.UtcNow;
// A server MUST NOT mask any frames that it sends to the client. A client MUST close a connection if it detects a masked frame.
// In this case, it MAY use the status code 1002 (protocol error)
// (These rules might be relaxed in a future specification.)
if (frame.HasMask)
{
Close(1002, "Protocol Error: masked frame received from server!");
continue;
}
if (!frame.IsFinal)
{
if (OnIncompleteFrame == null)
{
IncompleteFrames.Add(frame);
}
else
{
CompletedFrames.Enqueue(frame);
}
continue;
}
switch (frame.Type)
{
// For a complete documentation and rules on fragmentation see http://tools.ietf.org/html/rfc6455#section-5.4
// A fragmented Frame's last fragment's opcode is 0 (Continuation) and the FIN bit is set to 1.
case WebSocketFrameTypes.Continuation:
// Do an assemble pass only if OnFragment is not set. Otherwise put it in the CompletedFrames, we will handle it in the HandleEvent phase.
if (OnIncompleteFrame == null)
{
frame.Assemble(IncompleteFrames);
// Remove all incomplete frames
IncompleteFrames.Clear();
// Control frames themselves MUST NOT be fragmented. So, its a normal text or binary frame. Go, handle it as usual.
goto case WebSocketFrameTypes.Binary;
}
else
{
CompletedFrames.Enqueue(frame);
}
break;
case WebSocketFrameTypes.Text:
case WebSocketFrameTypes.Binary:
frame.DecodeWithExtensions(WebSocket);
CompletedFrames.Enqueue(frame);
break;
// Upon receipt of a Ping frame, an endpoint MUST send a Pong frame in response, unless it already received a Close frame.
case WebSocketFrameTypes.Ping:
if (!closeSent && !closed)
{
Send(new WebSocketFrame(this.WebSocket, WebSocketFrameTypes.Pong, frame.Data));
}
break;
case WebSocketFrameTypes.Pong:
try
{
// Get the ticks from the frame's payload
long ticksSent = BitConverter.ToInt64(frame.Data, 0);
// the difference between the current time and the time when the ping message is sent
TimeSpan diff = TimeSpan.FromTicks(lastMessage.Ticks - ticksSent);
// add it to the buffer
this.rtts.Add((int)diff.TotalMilliseconds);
// and calculate the new latency
this.Latency = CalculateLatency();
}
catch
{
// https://tools.ietf.org/html/rfc6455#section-5.5
// A Pong frame MAY be sent unsolicited. This serves as a
// unidirectional heartbeat. A response to an unsolicited Pong frame is
// not expected.
}
break;
// If an endpoint receives a Close frame and did not previously send a Close frame, the endpoint MUST send a Close frame in response.
case WebSocketFrameTypes.ConnectionClose:
CloseFrame = frame;
if (!closeSent)
{
Send(new WebSocketFrame(this.WebSocket, WebSocketFrameTypes.ConnectionClose, null));
}
closed = true;
break;
}
}
#if !NETFX_CORE
catch (ThreadAbortException)
{
IncompleteFrames.Clear();
this.baseRequest.State = HTTPRequestStates.Aborted;
closed = true;
newFrameSignal.Set();
}
#endif
catch (Exception e)
{
if (HTTPUpdateDelegator.IsCreated)
{
this.baseRequest.Exception = e;
this.baseRequest.State = HTTPRequestStates.Error;
}
else
{
this.baseRequest.State = HTTPRequestStates.Aborted;
}
closed = true;
newFrameSignal.Set();
}
}
}
}
finally
{
HTTPManager.Heartbeats.Unsubscribe(this);
HTTPUpdateDelegator.OnApplicationForegroundStateChanged -= OnApplicationForegroundStateChanged;
HTTPManager.Logger.Information("WebSocketResponse", "ReceiveThread - Closed!");
}
}
private void ReadThread()
{
try
{
Thread.CurrentThread.Name = "HTTP2 Read";
HTTPManager.Logger.Information("HTTP2Handler", "Reader thread up and running!");
using (ReadOnlyBufferedStream bufferedStream = new ReadOnlyBufferedStream(this.conn.connector.Stream, 32 * 1024))
{
while (this.isRunning)
{
// TODO:
// 1. Set the local window to a reasonable size
// 2. stop reading when the local window is about to be 0.
// 3.
HTTP2FrameHeaderAndPayload header = HTTP2FrameHelper.ReadHeader(bufferedStream);
if (HTTPManager.Logger.Level <= Logger.Loglevels.Information && header.Type != HTTP2FrameTypes.DATA /*&& header.Type != HTTP2FrameTypes.PING*/)
{
HTTPManager.Logger.Information("HTTP2Handler", "New frame received: " + header.ToString());
}
// Add the new frame to the queue. Processing it on the write thread gives us the advantage that
// we don't have to deal with too much locking.
this.newFrames.Enqueue(header);
// ping write thread to process the new frame
this.newFrameSignal.Set();
switch (header.Type)
{
// Handle pongs on the read thread, so no additional latency is added to the rtt calculation.
case HTTP2FrameTypes.PING:
var pingFrame = HTTP2FrameHelper.ReadPingFrame(header);
if ((pingFrame.Flags & HTTP2PingFlags.ACK) != 0)
{
// it was an ack, payload must contain what we sent
var ticks = BufferHelper.ReadLong(pingFrame.OpaqueData, 0);
// the difference between the current time and the time when the ping message is sent
TimeSpan diff = TimeSpan.FromTicks(DateTime.UtcNow.Ticks - ticks);
// add it to the buffer
this.rtts.Add(diff.TotalMilliseconds);
// and calculate the new latency
this.Latency = CalculateLatency();
HTTPManager.Logger.Verbose("HTTP2Handler", string.Format("Latency: {0:F2}ms, RTT buffer: {1}", this.Latency, this.rtts.ToString()));
}
break;
case HTTP2FrameTypes.GOAWAY:
// Just exit from this thread. The processing thread will handle the frame too.
return;
}
}
}
}
catch //(Exception ex)
{
//HTTPManager.Logger.Exception("HTTP2Handler", "", ex);
this.isRunning = false;
this.newFrameSignal.Set();
}
finally
{
// First thread closing notifies the ConnectionEventHelper
if (Interlocked.Increment(ref this.threadExitCount) == 1)
{
ConnectionEventHelper.EnqueueConnectionEvent(new ConnectionEventInfo(this.conn, HTTPConnectionStates.Closed));
}
HTTPManager.Logger.Information("HTTP2Handler", "Reader thread closing");
}
}
