public static IEnumerable <DataTransferDatagram> Build(Rfc1006ProtocolContext context, Memory <byte> rawPayload)
        {
            var result  = new List <DataTransferDatagram>();
            var payload = rawPayload;

            do
            {
                var frame = payload.Slice(0, Math.Min(payload.Length, context.FrameSizeSending));
                payload = payload.Slice(frame.Length);

                var current = new DataTransferDatagram
                {
                    _payload = MemoryPool <byte> .Shared.Rent(frame.Length)
                };
                current.Payload = current._payload.Memory.Slice(0, frame.Length);

                frame.CopyTo(current.Payload);
                if (payload.Length > 0)
                {
                    current.TpduNr = 0x00;
                }

                current.Tkpt.Length = Convert.ToUInt16(frame.Length + Rfc1006ProtocolContext.DataHeaderSize);
                result.Add(current);
            } while (payload.Length > 0);
            return(result);
        }
Exemple #2
0
        public static DataTransferDatagram TranslateFromMemory(Memory <byte> data, out int processed)
        {
            var span       = data.Span;
            var tkptLength = BinaryPrimitives.ReadUInt16BigEndian(span.Slice(2, 2));

            if (data.Length < tkptLength)
            {
                processed = 0;
                return(null);
            }

            var result = new DataTransferDatagram
            {
                Tkpt = new TpktDatagram
                {
                    Sync1  = span[0],
                    Sync2  = span[1],
                    Length = tkptLength
                },
                Li      = span[4],
                PduType = span[5],
                TpduNr  = span[6]
            };


            var length = result.Tkpt.Length - Rfc1006ProtocolContext.DataHeaderSize;

            result.Payload = data.Slice(Rfc1006ProtocolContext.DataHeaderSize, length);
            processed      = result.Tkpt.Length;
            return(result);
        }
        public static Memory <byte> TranslateToMemory(DataTransferDatagram datagram, Memory <byte> buffer)
        {
            var span = buffer.Span;

            span[0] = datagram.Tkpt.Sync1;
            span[1] = datagram.Tkpt.Sync2;
            BinaryPrimitives.WriteUInt16BigEndian(span.Slice(2, 2), datagram.Tkpt.Length);
            span[4] = datagram.Li;
            span[5] = datagram.PduType;
            span[6] = datagram.TpduNr;
            datagram.Payload.CopyTo(buffer.Slice(7));

            return(buffer);
        }
        public static Memory <byte> TranslateToMemory(DataTransferDatagram datagram)
        {
            var length = datagram.Tkpt.Length;
            var result = new Memory <byte>(new byte[length]);  // check if we could use ArrayBuffer
            var span   = result.Span;

            span[0] = datagram.Tkpt.Sync1;
            span[1] = datagram.Tkpt.Sync2;
            BinaryPrimitives.WriteUInt16BigEndian(span.Slice(2, 2), datagram.Tkpt.Length);
            span[4] = datagram.Li;
            span[5] = datagram.PduType;
            span[6] = datagram.TpduNr;

            datagram.Payload.CopyTo(result.Slice(7));

            return(result);
        }
        public static DataTransferDatagram TranslateFromMemory(Memory <byte> data, out int processed)
        {
            var span   = data.Span;
            var result = new DataTransferDatagram
            {
                Tkpt = new TpktDatagram
                {
                    Sync1  = span[0],
                    Sync2  = span[1],
                    Length = BinaryPrimitives.ReadUInt16BigEndian(span.Slice(2, 2))
                },
                Li      = span[4],
                PduType = span[5],
                TpduNr  = span[6]
            };

            var length = result.Tkpt.Length - 7;

            result.Payload = data.Slice(7, length);
            processed      = result.Tkpt.Length;
            return(result);
        }
 public static ushort GetRawDataLength(DataTransferDatagram datagram) => datagram.Tkpt.Length;