private unsafe void TestIndexOfWorksForAllLocations(ref ReadableBuffer readBuffer, byte emptyValue)
{
byte huntValue = (byte)~emptyValue;
// we're going to fully index the final locations of the buffer, so that we
// can mutate etc in constant time
var addresses = BuildPointerIndex(ref readBuffer);
// check it isn't there to start with
ReadableBuffer slice;
ReadCursor cursor;
var found = readBuffer.TrySliceTo(huntValue, out slice, out cursor);
Assert.False(found);
// correctness test all values
for (int i = 0; i < readBuffer.Length; i++)
{
*addresses[i] = huntValue;
found = readBuffer.TrySliceTo(huntValue, out slice, out cursor);
*addresses[i] = emptyValue;
Assert.True(found);
var remaining = readBuffer.Slice(cursor);
void *pointer;
Assert.True(remaining.First.TryGetPointer(out pointer));
Assert.True((byte *)pointer == addresses[i]);
}
}
private static ReadCursor ProcessHeader(HttpContext context, ref ReadableBuffer currentSlice)
{
if (!currentSlice.TrySliceTo(HttpConsts.EndOfLine, out ReadableBuffer headerLine, out ReadCursor cursor))
{
headerLine = currentSlice;
currentSlice = currentSlice.Slice(currentSlice.Length);
}
public SomeDataUpdate(ref ReadableBuffer buffer)
{
Bid1 = buffer.ReadBigEndian <int>();
buffer = buffer.Slice(4);
Bid2 = buffer.ReadBigEndian <int>();
buffer = buffer.Slice(4);
Bid3 = buffer.ReadBigEndian <int>();
buffer = buffer.Slice(4);
Bid4 = buffer.ReadBigEndian <int>();
buffer = buffer.Slice(4);
Ask1 = buffer.ReadBigEndian <int>();
buffer = buffer.Slice(4);
Ask2 = buffer.ReadBigEndian <int>();
buffer = buffer.Slice(4);
Ask3 = buffer.ReadBigEndian <int>();
buffer = buffer.Slice(4);
Ask4 = buffer.ReadBigEndian <int>();
buffer = buffer.Slice(4);
Size1 = buffer.ReadBigEndian <int>();
buffer = buffer.Slice(4);
Size2 = buffer.ReadBigEndian <int>();
buffer = buffer.Slice(4);
Size3 = buffer.ReadBigEndian <int>();
buffer = buffer.Slice(4);
Size4 = buffer.ReadBigEndian <int>();
buffer = buffer.Slice(4);
ReadableBuffer stringBuffer;
ReadCursor endCursor;
buffer.TrySliceTo(0x00, out stringBuffer, out endCursor);
SecurityCode = stringBuffer.GetAsciiString();
buffer = buffer.Slice(endCursor).Slice(1);
}
private unsafe void TestIndexOfWorksForAllLocations(ref ReadableBuffer readBuffer, byte emptyValue)
{
byte huntValue = (byte)~emptyValue;
var handles = new List <BufferHandle>();
// we're going to fully index the final locations of the buffer, so that we
// can mutate etc in constant time
var addresses = BuildPointerIndex(ref readBuffer, handles);
// check it isn't there to start with
ReadableBuffer slice;
ReadCursor cursor;
var found = readBuffer.TrySliceTo(huntValue, out slice, out cursor);
Assert.False(found);
// correctness test all values
for (int i = 0; i < readBuffer.Length; i++)
{
*addresses[i] = huntValue;
found = readBuffer.TrySliceTo(huntValue, out slice, out cursor);
*addresses[i] = emptyValue;
Assert.True(found);
var remaining = readBuffer.Slice(cursor);
var handle = remaining.First.Retain(pin: true);
Assert.True(handle.PinnedPointer != null);
if (i % BlockSize == 0)
{
Assert.True((byte *)handle.PinnedPointer == addresses[i]);
}
handle.Dispose();
}
// free up memory handles
foreach (var handle in handles)
{
handle.Dispose();
}
handles.Clear();
}
public override TPackageInfo Filter(ref ReadableBuffer buffer)
{
ReadableBuffer slice;
ReadCursor cursor;
if (!buffer.TrySliceTo(new Span <byte>(_terminator), out slice, out cursor))
{
return(null);
}
buffer = buffer.Slice(cursor).Slice(_terminator.Length);
return(ResolvePackage(slice));
}
public bool TryDecode(ref ReadableBuffer input, out Line frame)
{
if (input.TrySliceTo((byte)'\r', (byte)'\n', out ReadableBuffer slice, out ReadCursor cursor))
{
frame = new Line {
Data = slice.GetUtf8Span()
};
input = input.Slice(cursor).Slice(1);
return(true);
}
frame = null;
return(false);
}
private static object ReadSimpleStringAsync(this ReadableBuffer buffer)
{
// Find \n
ReadCursor delim;
ReadableBuffer line;
if (!buffer.TrySliceTo((byte)'\r', (byte)'\n', out line, out delim))
{
return(new RedisErrorString("Unable to read line"));
}
PreservedBuffer preservedBuffer = line.Preserve();
// Move the buffer to the rest
buffer = buffer.Slice(delim).Slice(2);
return(preservedBuffer);
}
public ParseResult ParseRequest(ref ReadableBuffer buffer)
{
if (_state == ParsingState.StartLine)
{
// Find \n
ReadCursor delim;
ReadableBuffer startLine;
if (!buffer.TrySliceTo((byte)'\r', (byte)'\n', out startLine, out delim))
{
return(ParseResult.Incomplete);
}
// Move the buffer to the rest
buffer = buffer.Slice(delim).Slice(2);
ReadableBuffer method;
if (!startLine.TrySliceTo((byte)' ', out method, out delim))
{
return(ParseResult.BadRequest);
}
Method = method.Preserve();
// Skip ' '
startLine = startLine.Slice(delim).Slice(1);
ReadableBuffer path;
if (!startLine.TrySliceTo((byte)' ', out path, out delim))
{
return(ParseResult.BadRequest);
}
Path = path.Preserve();
// Skip ' '
startLine = startLine.Slice(delim).Slice(1);
var httpVersion = startLine;
if (httpVersion.IsEmpty)
{
return(ParseResult.BadRequest);
}
HttpVersion = httpVersion.Preserve();
_state = ParsingState.Headers;
}
// Parse headers
// key: value\r\n
while (!buffer.IsEmpty)
{
var headerName = default(ReadableBuffer);
var headerValue = default(ReadableBuffer);
// End of the header
// \n
ReadCursor delim;
ReadableBuffer headerPair;
if (!buffer.TrySliceTo((byte)'\r', (byte)'\n', out headerPair, out delim))
{
return(ParseResult.Incomplete);
}
buffer = buffer.Slice(delim).Slice(2);
// End of headers
if (headerPair.IsEmpty)
{
return(ParseResult.Complete);
}
// :
if (!headerPair.TrySliceTo((byte)':', out headerName, out delim))
{
return(ParseResult.BadRequest);
}
headerName = headerName.TrimStart();
headerPair = headerPair.Slice(delim).Slice(1);
headerValue = headerPair.TrimStart();
RequestHeaders.SetHeader(ref headerName, ref headerValue);
}
return(ParseResult.Incomplete);
}
public ParseResult ParseRequest(ref ReadableBuffer buffer)
{
if (_state == ParsingState.StartLine)
{
// Find \n
ReadCursor delim;
ReadableBuffer startLine;
if (!buffer.TrySliceTo((byte)'\r', (byte)'\n', out startLine, out delim))
{
return ParseResult.Incomplete;
}
// Move the buffer to the rest
buffer = buffer.Slice(delim).Slice(2);
ReadableBuffer method;
if (!startLine.TrySliceTo((byte)' ', out method, out delim))
{
return ParseResult.BadRequest;
}
_method = method.Preserve();
// Skip ' '
startLine = startLine.Slice(delim).Slice(1);
ReadableBuffer path;
if (!startLine.TrySliceTo((byte)' ', out path, out delim))
{
return ParseResult.BadRequest;
}
_path = path.Preserve();
// Skip ' '
startLine = startLine.Slice(delim).Slice(1);
var httpVersion = startLine;
if (httpVersion.IsEmpty)
{
return ParseResult.BadRequest;
}
_httpVersion = httpVersion.Preserve();
_state = ParsingState.Headers;
}
// Parse headers
// key: value\r\n
while (!buffer.IsEmpty)
{
var headerName = default(ReadableBuffer);
var headerValue = default(ReadableBuffer);
// End of the header
// \n
ReadCursor delim;
ReadableBuffer headerPair;
if (!buffer.TrySliceTo((byte)'\r', (byte)'\n', out headerPair, out delim))
{
return ParseResult.Incomplete;
}
buffer = buffer.Slice(delim).Slice(2);
// End of headers
if (headerPair.IsEmpty)
{
return ParseResult.Complete;
}
// :
if (!headerPair.TrySliceTo((byte)':', out headerName, out delim))
{
return ParseResult.BadRequest;
}
headerName = headerName.TrimStart();
headerPair = headerPair.Slice(delim).Slice(1);
headerValue = headerPair.TrimStart();
RequestHeaders.SetHeader(ref headerName, ref headerValue);
}
return ParseResult.Incomplete;
}
private unsafe void TestIndexOfWorksForAllLocations(ref ReadableBuffer readBuffer, byte emptyValue)
{
byte huntValue = (byte)~emptyValue;
// we're going to fully index the final locations of the buffer, so that we
// can mutate etc in constant time
var addresses = BuildPointerIndex(ref readBuffer);
// check it isn't there to start with
ReadableBuffer slice;
ReadCursor cursor;
var found = readBuffer.TrySliceTo(huntValue, out slice, out cursor);
Assert.False(found);
// correctness test all values
for (int i = 0; i < readBuffer.Length; i++)
{
*addresses[i] = huntValue;
found = readBuffer.TrySliceTo(huntValue, out slice, out cursor);
*addresses[i] = emptyValue;
Assert.True(found);
var remaining = readBuffer.Slice(cursor);
void* pointer;
Assert.True(remaining.First.TryGetPointer(out pointer));
Assert.True((byte*)pointer == addresses[i]);
}
}
public ParseResult ParseRequest(ReadableBuffer buffer, out ReadCursor consumed, out ReadCursor examined)
{
consumed = buffer.Start;
examined = buffer.Start;
if (_state == ParsingState.StartLine)
{
if (!buffer.TrySliceTo((byte)'\r', (byte)'\n', out ReadableBuffer startLine, out ReadCursor delim))
{
return(ParseResult.Incomplete);
}
// Move the buffer to the rest
buffer = buffer.Slice(delim).Slice(2);
if (!startLine.TrySliceTo((byte)' ', out ReadableBuffer method, out delim))
{
return(ParseResult.BadRequest);
}
_method = method.ToArray();
// Skip ' '
startLine = startLine.Slice(delim).Slice(1);
if (!startLine.TrySliceTo((byte)' ', out ReadableBuffer path, out delim))
{
return(ParseResult.BadRequest);
}
_path = path.ToArray();
// Skip ' '
startLine = startLine.Slice(delim).Slice(1);
var httpVersion = startLine;
if (httpVersion.IsEmpty)
{
return(ParseResult.BadRequest);
}
_httpVersion = httpVersion.ToArray();
_state = ParsingState.Headers;
consumed = buffer.Start;
examined = buffer.Start;
}
// Parse headers
// key: value\r\n
while (!buffer.IsEmpty)
{
var headerValue = default(ReadableBuffer);
if (!buffer.TrySliceTo((byte)'\r', (byte)'\n', out ReadableBuffer headerPair, out ReadCursor delim))
{
return(ParseResult.Incomplete);
}
buffer = buffer.Slice(delim).Slice(2);
consumed = buffer.Start;
examined = buffer.Start;
// End of headers
if (headerPair.IsEmpty)
{
return(ParseResult.Complete);
}
// :
if (!headerPair.TrySliceTo((byte)':', out ReadableBuffer headerName, out delim))
{
return(ParseResult.BadRequest);
}
headerName = headerName.TrimStart();
headerPair = headerPair.Slice(delim).Slice(1);
headerValue = headerPair.TrimStart();
RequestHeaders.SetHeader(ref headerName, ref headerValue);
}
return(ParseResult.Incomplete);
}
