private bool ProcessHandshakeC2(ReadOnlySequence <byte> buffer, ref int consumed) { if (buffer.Length - consumed < 1536) { return(false); } var arr = _arrayPool.Rent(1536); try { buffer.Slice(consumed, 1536).CopyTo(arr); consumed += 1536; var s1Timestamp = NetworkBitConverter.ToUInt32(arr.AsSpan(0, 4)); if (s1Timestamp != _writerTimestampEpoch) { throw new ProtocolViolationException(); } if (!arr.AsSpan(8, 1528).SequenceEqual(_s1Data.AsSpan(0, 1528))) { throw new ProtocolViolationException(); } _ioPipeline.OnHandshakeSuccessful(); return(true); } finally { _arrayPool.Return(_s1Data); _arrayPool.Return(arr); _s1Data = null; Dispose(); } }
private MessageData DeserializeMessage(Span <byte> buffer, out int consumed) { consumed = 0; var header = new MessageHeader(); header.MessageType = (MessageType)buffer[0]; buffer = buffer.Slice(sizeof(byte)); consumed += sizeof(byte); header.MessageLength = NetworkBitConverter.ToUInt24(buffer); buffer = buffer.Slice(3); consumed += 3; header.Timestamp = NetworkBitConverter.ToUInt32(buffer); buffer = buffer.Slice(sizeof(uint)); consumed += sizeof(uint); header.MessageStreamId = header.MessageStreamId; // Override message stream id buffer = buffer.Slice(3); consumed += 3; var offset = consumed; consumed += (int)header.MessageLength; header.Timestamp += MessageHeader.Timestamp; return(new MessageData() { Header = header, DataOffset = offset, DataLength = header.MessageLength }); }
public override void Deserialize(SerializationContext context) { var span = context.ReadBuffer.Span; var eventType = (UserControlEventType)NetworkBitConverter.ToUInt16(span); span = span.Slice(sizeof(ushort)); Contract.Assert(eventType == UserControlEventType.StreamIsRecorded); StreamID = NetworkBitConverter.ToUInt32(span); }
public bool ReadNet32(out uint x) { if (position + 4 > count) { x = 0; return(false); } x = NetworkBitConverter.ToUInt32(data, position); position += 4; return(true); }
private bool ProcessHandshakeC0C1(ReadOnlySequence <byte> buffer, ref int consumed) { if (buffer.Length - consumed < 1537) { return(false); } var arr = _arrayPool.Rent(1537); try { buffer.Slice(consumed, 9).CopyTo(arr); consumed += 9; var version = arr[0]; //本文档中规范的版本号为 3。0、1、2 三个值是由早期其他产品使用的,是废弃值;4 - 31 被保留为 RTMP 协议的未来实现版本使用 if (version < 3) { throw new NotSupportedException(); } if (version > 31) { throw new ProtocolViolationException(); } _readerTimestampEpoch = NetworkBitConverter.ToUInt32(arr.AsSpan(1, 4)); _writerTimestampEpoch = 0; _s1Data = _arrayPool.Rent(1528); _random.NextBytes(_s1Data.AsSpan(0, 1528)); // s0s1 arr.AsSpan().Clear(); arr[0] = 3; NetworkBitConverter.TryGetBytes(_writerTimestampEpoch, arr.AsSpan(1, 4)); _s1Data.AsSpan(0, 1528).CopyTo(arr.AsSpan(9)); _ = _ioPipeline.SendRawData(arr.AsMemory(0, 1537)); // s2 NetworkBitConverter.TryGetBytes(_readerTimestampEpoch, arr.AsSpan(0, 4)); NetworkBitConverter.TryGetBytes((uint)0, arr.AsSpan(4, 4)); _ = _ioPipeline.SendRawData(arr.AsMemory(0, 1536)); buffer.Slice(consumed, 1528).CopyTo(arr.AsSpan(8)); consumed += 1528; _ioPipeline.NextProcessState = ProcessState.HandshakeC2; return(true); } finally { _arrayPool.Return(arr); } }
public static ResourceRecord Parse(byte [] buffer, ref int offset) { string name; if ((buffer[offset] & 0xc0) == 0xc0) { // Detected compression. Name is at offset in // lower 14 bits of next 2 bytes. int start = NetworkBitConverter.ToInt16(buffer, offset); if (LabelEncoding.GetString(buffer, start & 0x3fff, out name) == 0) { throw new InvalidDnsFormatException("name"); } offset += 2; } else { int used = LabelEncoding.GetString(buffer, offset, out name); if (used == 0) { throw new InvalidDnsFormatException("name"); } offset += used; } ushort rType = NetworkBitConverter.ToUInt16(buffer, offset); offset += 2; ushort rClass = NetworkBitConverter.ToUInt16(buffer, offset); offset += 2; uint ttlSeconds = NetworkBitConverter.ToUInt32(buffer, offset); offset += 4; ushort rdataLength = NetworkBitConverter.ToUInt16(buffer, offset); offset += 2; byte [] rdata = new byte[rdataLength]; Array.Copy(buffer, offset, rdata, 0, rdataLength); offset += rdataLength; return(new ResourceRecord(name, (Type)rType, (Class)rClass, ttlSeconds, rdata)); }
public ArpHeader(Bytes packet, ushort index) { //since this is already known to be an arp request //we skip the sanity checks... VTable.Assert(packet.Length - index >= 96); // check hardware type == 0x0001 (Ethernet) htype = NetworkBitConverter.ToUInt16(packet, index); DebugStub.Assert(htype == 0x001); index += 2; // check protocol type == 0x0800 (IP) ptype = NetworkBitConverter.ToUInt16(packet, index); DebugStub.Assert(ptype == 0x0800); index += 2; // check hardware address len is 6 bytes hlen = packet[index++]; DebugStub.Assert(hlen == 6); // check IP address len is 4 bytes plen = packet[index++]; DebugStub.Assert(plen == 4); op = NetworkBitConverter.ToUInt16(packet, index); index += 2; senderEthernetAddr = EthernetAddress.ParseBytes(packet.Array, packet.Start + index); index += EthernetAddress.Length; uint addr = NetworkBitConverter.ToUInt32(packet, index); index += 4; senderIPAddr = new IPv4(addr); destEthernetAddr = EthernetAddress.ParseBytes(packet.Array, packet.Start + index); index += EthernetAddress.Length; addr = NetworkBitConverter.ToUInt32(packet, index); index += 4; destIPAddr = new IPv4(addr); //sgc complains pad0 = 0; pad1 = 0; }
public bool TryGetStrictArray(Span <byte> buffer, out List <object> array, out int consumedLength) { array = default; consumedLength = default; if (!TryDescribeData(buffer, out var type, out _)) { return(false); } if (type != Amf0Type.StrictArray) { return(false); } var obj = new List <object>(); _referenceTable.Add(obj); var elementCount = NetworkBitConverter.ToUInt32(buffer.Slice(Amf0CommonValues.MARKER_LENGTH, sizeof(uint))); int consumed = Amf0CommonValues.MARKER_LENGTH + sizeof(uint); var arrayBodyBuffer = buffer.Slice(consumed); var elementBodyBuffer = arrayBodyBuffer; System.Diagnostics.Debug.WriteLine(elementCount); for (uint i = 0; i < elementCount; i++) { if (!TryGetValue(elementBodyBuffer, out _, out var element, out var bufferConsumed)) { return(false); } obj.Add(element); if (elementBodyBuffer.Length - bufferConsumed < 0) { return(false); } elementBodyBuffer = elementBodyBuffer.Slice(bufferConsumed); consumed += bufferConsumed; } array = obj; consumedLength = consumed; return(true); }
public bool TryGetMessage(Span <byte> buffer, out Message message, out int consumed) { message = default; consumed = default; if (!TryGetStringImpl(buffer, Amf0CommonValues.STRING_HEADER_LENGTH, out var targetUri, out var targetUriConsumed)) { return(false); } buffer = buffer.Slice(targetUriConsumed); if (!TryGetStringImpl(buffer, Amf0CommonValues.STRING_HEADER_LENGTH, out var responseUri, out var responseUriConsumed)) { return(false); } buffer = buffer.Slice(responseUriConsumed); if (buffer.Length < sizeof(uint)) { return(false); } var messageLength = NetworkBitConverter.ToUInt32(buffer); if (messageLength >= 0 && buffer.Length < messageLength) { return(false); } if (messageLength == 0 && StrictMode) { return(true); } buffer = buffer.Slice(sizeof(uint)); if (!TryGetValue(buffer, out _, out var content, out var contentConsumed)) { return(false); } consumed = targetUriConsumed + responseUriConsumed + sizeof(uint) + contentConsumed; message = new Message() { TargetUri = targetUri, ResponseUri = responseUri, Content = content }; return(true); }
//create a byte aligned ipheader //index marks the starting location of the ip header within the buffer public IpHeader(Bytes packet, int index) { //assert that the packet is large enough for a ipheader VTable.Assert(packet.Length - index > 20); verLen = packet[index++]; tos = packet[index++]; totalLength = NetworkBitConverter.ToUInt16(packet, index); index += 2; id = NetworkBitConverter.ToUInt16(packet, index); index += 2; offset = NetworkBitConverter.ToUInt16(packet, index); index += 2; ttl = packet[index++]; protocol = packet[index++]; checksum = NetworkBitConverter.ToUInt16(packet, index); index += 2; uint addr; addr = NetworkBitConverter.ToUInt32(packet, index); srcAddress = new IPv4(addr); index += 4; addr = NetworkBitConverter.ToUInt32(packet, index); destAddress = new IPv4(addr); #if false DebugStub.Print("IpHeader verlen 0x{0,8:x}\n tos {1}\n" + " totalLength {2}\n ttl {3}\n protocol 0x{4,4:x}\n" + " checksum 0x{5,4:x}\n src {6}\n, dest {7}\n", DebugStub.ArgList(verLen, tos, totalLength, ttl, protocol, checksum, srcAddress, destAddress)); #endif //sgc complains... pad0 = 0; pad1 = 0; pad2 = 0; pad3 = 0; }
internal bool TryGetStringImpl(Span <byte> buffer, int lengthOfLengthField, out string value, out int consumedLength) { value = default; consumedLength = default; var stringLength = 0; if (lengthOfLengthField == Amf0CommonValues.STRING_HEADER_LENGTH) { stringLength = (int)NetworkBitConverter.ToUInt16(buffer); } else { stringLength = (int)NetworkBitConverter.ToUInt32(buffer); } if (buffer.Length - lengthOfLengthField < stringLength) { return(false); } value = Encoding.UTF8.GetString(buffer.Slice(lengthOfLengthField, stringLength)); consumedLength = lengthOfLengthField + stringLength; return(true); }
public override void Deserialize(SerializationContext context) { BytesReceived = NetworkBitConverter.ToUInt32(context.ReadBuffer.Span); }
public override void Deserialize(SerializationContext context) { WindowSize = NetworkBitConverter.ToUInt32(context.ReadBuffer.Span); }
public override void Deserialize(SerializationContext context) { AbortedChunkStreamId = NetworkBitConverter.ToUInt32(context.ReadBuffer.Span); }
public bool TryGetEcmaArray(Span <byte> buffer, out Dictionary <string, object> value, out int consumedLength) { value = default; consumedLength = default; int consumed = 0; if (!TryDescribeData(buffer, out var type, out _)) { return(false); } if (type != Amf0Type.EcmaArray) { return(false); } var obj = new Dictionary <string, object>(); _referenceTable.Add(obj); var elementCount = NetworkBitConverter.ToUInt32(buffer.Slice(Amf0CommonValues.MARKER_LENGTH, sizeof(uint))); var arrayBodyBuffer = buffer.Slice(Amf0CommonValues.MARKER_LENGTH + sizeof(uint)); consumed = Amf0CommonValues.MARKER_LENGTH + sizeof(uint); if (StrictMode) { for (int i = 0; i < elementCount; i++) { if (!TryGetKeyValuePair(arrayBodyBuffer, out var kv, out _, out var kvConsumed)) { return(false); } arrayBodyBuffer = arrayBodyBuffer.Slice(kvConsumed); consumed += kvConsumed; obj.Add(kv.Key, kv.Value); } if (!TryGetStringImpl(arrayBodyBuffer, Amf0CommonValues.STRING_HEADER_LENGTH, out var emptyStr, out var emptyStrConsumed)) { return(false); } if (emptyStr.Any()) { return(false); } consumed += emptyStrConsumed; arrayBodyBuffer = arrayBodyBuffer.Slice(emptyStrConsumed); if (!TryDescribeData(arrayBodyBuffer, out var objEndType, out var objEndConsumed)) { return(false); } if (objEndType != Amf0Type.ObjectEnd) { return(false); } consumed += objEndConsumed; } else { while (true) { if (!TryGetKeyValuePair(arrayBodyBuffer, out var kv, out var isEnd, out var kvConsumed)) { return(false); } arrayBodyBuffer = arrayBodyBuffer.Slice(kvConsumed); consumed += kvConsumed; if (isEnd) { break; } obj.Add(kv.Key, kv.Value); } } value = obj; consumedLength = consumed; return(true); }
public override void Deserialize(SerializationContext context) { WindowSize = NetworkBitConverter.ToUInt32(context.ReadBuffer.Span); LimitType = (LimitType)context.ReadBuffer.Span.Slice(sizeof(uint))[0]; }
public static DhcpFormat Parse(Bytes buffer) { DhcpFormat p = new DhcpFormat(BootType.NotSpecified); p.optionsUsedLength = 0; if (buffer.Length < DhcpFormat.MinLength) { throw new InvalidDhcpFormatException("Format less than minimum size"); } int offset = 0; p.op = buffer[offset++]; if (p.op != (byte)BootType.Request && p.op != (byte)BootType.Reply) { throw new InvalidDhcpFormatException("Bad Type (op = {0})", p.op); } p.htype = buffer[offset++]; // No check p.hlen = buffer[offset++]; if (p.hlen > HardwareAddressLength) { throw new InvalidDhcpFormatException("Bad address length (hlen {0})", p.hlen); } p.hops = buffer[offset++]; // No check p.xid = NetworkBitConverter.ToUInt32(buffer, offset); offset += 4; p.secs = NetworkBitConverter.ToUInt16(buffer, offset); offset += 2; p.flags = NetworkBitConverter.ToUInt16(buffer, offset); offset += 2; p.ciaddr = NetworkBitConverter.ToUInt32(buffer, offset); offset += 4; p.yiaddr = NetworkBitConverter.ToUInt32(buffer, offset); offset += 4; p.siaddr = NetworkBitConverter.ToUInt32(buffer, offset); offset += 4; p.giaddr = NetworkBitConverter.ToUInt32(buffer, offset); offset += 4; Bitter.ToByteArray(buffer, offset, HardwareAddressLength, p.chaddr, 0); offset += HardwareAddressLength; Bitter.ToByteArray(buffer, offset, ServerNameLength, p.sname, 0); offset += ServerNameLength; Bitter.ToByteArray(buffer, offset, BootFileLength, p.file, 0); offset += BootFileLength; p.cookie = NetworkBitConverter.ToUInt32(buffer, offset); offset += 4; if (p.cookie != DhcpCookie) { throw new InvalidDhcpFormatException("Bad cookie (0x{0x:x8})", p.cookie); } int available = buffer.Length - offset; if (available > p.options.Length) { p.options = new byte [available]; } p.optionsUsedLength = available; Bitter.ToByteArray(buffer, offset, available, p.options, 0); return(p); }