private bool ParsePreface(ReadOnlySequence <byte> readableBuffer, out SequencePosition consumed, out SequencePosition examined)
{
consumed = readableBuffer.Start;
examined = readableBuffer.End;
if (readableBuffer.Length < ClientPreface.Length)
{
return(false);
}
var span = readableBuffer.IsSingleSegment
? readableBuffer.First.Span
: readableBuffer.ToSpan();
for (var i = 0; i < ClientPreface.Length; i++)
{
if (ClientPreface[i] != span[i])
{
throw new Http2ConnectionErrorException(CoreStrings.Http2ErrorInvalidPreface, Http2ErrorCode.PROTOCOL_ERROR);
}
}
consumed = examined = readableBuffer.GetPosition(ClientPreface.Length);
return(true);
}
private bool ParsePreface(ReadOnlySequence <byte> readableBuffer, out SequencePosition consumed, out SequencePosition examined)
{
consumed = readableBuffer.Start;
examined = readableBuffer.End;
if (readableBuffer.Length < ClientPreface.Length)
{
return(false);
}
var span = readableBuffer.IsSingleSegment
? readableBuffer.First.Span
: readableBuffer.ToSpan();
for (var i = 0; i < ClientPreface.Length; i++)
{
if (ClientPreface[i] != span[i])
{
throw new Exception("Invalid HTTP/2 connection preface.");
}
}
consumed = examined = readableBuffer.GetPosition(ClientPreface.Length);
return(true);
}
/// <summary>
/// Check whether a signature is normalized (lower-S).
/// </summary>
/// <param name="vchSig"></param>
/// <returns></returns>
public static bool CheckLowS(ReadOnlySequence<byte> vchSig)
{
var sig = new byte[64];
var input = vchSig.ToSpan();
using (var secp256k1 = new Secp256k1()) {
if (!secp256k1.SignatureParseDerLax(sig, input)) return false;
return !secp256k1.SignatureNormalize(Span<byte>.Empty, input);
}
}
public static IList <Proto2PeerSetting> ReadSettings(ReadOnlySequence <byte> payload)
{
var data = payload.ToSpan();
Debug.Assert(data.Length % SettingSize == 0, "Invalid settings payload length");
var settingsCount = data.Length / SettingSize;
var settings = new Proto2PeerSetting[settingsCount];
for (int i = 0; i < settings.Length; i++)
{
settings[i] = ReadSetting(data);
data = data.Slice(SettingSize);
}
return(settings);
}
public static string AsString(this ReadOnlySequence <byte> line, Encoding encoding)
{
return(encoding.GetString(line.ToSpan()));
}
public static bool TryParseUInt64(this ReadOnlySequence <byte> bufferSequence, out ulong value, out int consumed)
{
value = default;
consumed = default;
SequencePosition position = default;
// Fetch the first segment
if (!bufferSequence.TryGet(ref position, out ReadOnlyMemory <byte> first))
{
return(false);
}
// Attempt to parse the first segment. If it works (and it should in most cases), then return success.
bool parsed = Utf8Parser.TryParse(first.Span, out value, out consumed);
if (parsed && consumed < first.Length)
{
return(true);
}
// Apparently the we need data from the second segment to succesfully parse, and so fetch the second segment.
if (!bufferSequence.TryGet(ref position, out ReadOnlyMemory <byte> second))
{
// if there is no second segment and the first parsed succesfully, return the result of the parsing.
if (parsed)
{
return(true);
}
return(false);
}
// Combine the first, the second, and potentially more segments into a stack allocated buffer
if (first.Length < StackBufferSize)
{
Span <byte> destination = stackalloc byte[StackBufferSize];
first.Span.CopyTo(destination);
var free = destination.Slice(first.Length);
if (second.Length > free.Length)
{
second = second.Slice(0, free.Length);
}
second.Span.CopyTo(free);
free = free.Slice(second.Length);
while (free.Length > 0)
{
if (bufferSequence.TryGet(ref position, out ReadOnlyMemory <byte> next))
{
if (next.Length > free.Length)
{
next = next.Slice(0, free.Length);
}
next.Span.CopyTo(free);
free = free.Slice(next.Length);
}
else
{
break;
}
}
var combinedStackSpan = destination.Slice(0, StackBufferSize - free.Length);
// if the stack allocated buffer parsed succesfully (and for uint it should always do), then return success.
if (Utf8Parser.TryParse(combinedStackSpan, out value, out consumed))
{
if (consumed < combinedStackSpan.Length || combinedStackSpan.Length < StackBufferSize)
{
return(true);
}
}
}
// for invariant culture, we should never reach this point, as invariant uint text is never longer than 127 bytes.
// I left this code here, as we will need it for custom cultures and possibly when we shrink the stack allocated buffer.
var combinedSpan = bufferSequence.ToSpan();
if (!Utf8Parser.TryParse(combinedSpan, out value, out consumed))
{
return(false);
}
return(true);
}
private static ReadOnlySpan <byte> TrimSDPLineCR(ReadOnlySequence <byte> seq)
{
var line = seq.ToSpan();
return(TrimSDPLineCR(line));
}
public virtual string Encode(ReadOnlySequence <byte> bytes) => Encode(bytes.ToSpan());
public void NewToSpan()
{
var Result = Sequence.ToSpan();
}