コード例 #1
0
        public void WriteValue(string value)
        {
            if (value is null)
            {
                WriteByte(DataBytesDefinition.StringNull);
                return;
            }
            if (value == string.Empty)
            {
                WriteByte(DataBytesDefinition.StringEmpty);
                return;
            }

#if COMPATIBILITY
            var length = Encoding.UTF8.GetByteCount(value);

            var bufferLength = length + 5;
            var buffer       = ArrayPool <byte> .Shared.Rent(bufferLength);

            var bufferSpan = buffer.AsSpan(0, bufferLength);
            buffer[0] = DataBytesDefinition.StringLength;
            MemoryMarshal.Write(bufferSpan.Slice(1, 4), ref length);
            Encoding.UTF8.GetBytes(value, 0, value.Length, buffer, 5);
            Stream.Write(buffer, 0, bufferLength);
            ArrayPool <byte> .Shared.Return(buffer);
#else
            var length = Encoding.UTF8.GetByteCount(value);
            if (length <= 2048)
            {
                Span <byte> bufferSpan = stackalloc byte[length + 5];
                bufferSpan[0] = DataBytesDefinition.StringLength;
                BitConverter.TryWriteBytes(bufferSpan.Slice(1, 4), length);
                Encoding.UTF8.GetBytes(value, bufferSpan.Slice(5));
                Stream.Write(bufferSpan);
            }
            else
            {
                var buffer = ArrayPool <byte> .Shared.Rent(length + 5);

                var bufferSpan = buffer.AsSpan(0, length + 5);
                buffer[0] = DataBytesDefinition.StringLength;
                BitConverter.TryWriteBytes(bufferSpan.Slice(1, 4), length);
                Encoding.UTF8.GetBytes(value, bufferSpan.Slice(5));
                Stream.Write(bufferSpan);
                ArrayPool <byte> .Shared.Return(buffer);
            }
#endif
        }
コード例 #2
0
        /// <summary>
        /// Writes a 32 bit unsigned integer
        /// </summary>
        public void Write(UInt32 source)
        {
            EnsureBufferSize(m_bitLength + 32);

            // can write fast?
            if ((m_bitLength & 7) == 0)
            {
                MemoryMarshal.Write(new Span <byte>(Buffer, m_bitLength / 8, 4), ref source);
            }
            else
            {
                NetBitWriter.WriteUInt32(source, 32, Buffer, m_bitLength);
            }

            m_bitLength += 32;
        }
コード例 #3
0
            public int Append(
                int location, int collectionLength, int rowCount, NbtType type, NbtFlags flags)
            {
                if (ByteLength >= _data.Length - DbRow.Size)
                {
                    Enlarge();
                }

                var row = new DbRow(location, collectionLength, rowCount, type, flags);

                MemoryMarshal.Write(_data.AsSpan(ByteLength), ref row);
                int index = ByteLength;

                ByteLength += DbRow.Size;
                return(index);
            }
コード例 #4
0
        static async Task ProcessSocket(Socket socket, IPEndPoint endpoint)
        {
            var waypoint = new Waypoint()
            {
                MatchIndex = 3, WaypointIndex = 15, FlipY = true, X = 1.5f, Y = 1.6f
            };
            var buffer = new byte[Marshal.SizeOf(waypoint)];

            MemoryMarshal.Write(new Span <byte>(buffer), ref waypoint);
            while (true)
            {
                await socket
                .SendToAsync(buffer, SocketFlags.None, endpoint)
                .ConfigureAwait(false);
            }
        }
コード例 #5
0
            internal void Append(JsonTokenType tokenType, int startLocation, int length)
            {
                // StartArray or StartObject should have length -1, otherwise the length should not be -1.
                Debug.Assert(
                    (tokenType == JsonTokenType.StartArray || tokenType == JsonTokenType.StartObject) ==
                    (length == DbRow.UnknownSize));

                if (Length >= _rentedBuffer.Length - DbRow.Size)
                {
                    Enlarge();
                }

                DbRow row = new DbRow(tokenType, startLocation, length);

                MemoryMarshal.Write(_rentedBuffer.AsSpan(Length), ref row);
                Length += DbRow.Size;
            }
コード例 #6
0
ファイル: WSTransceiver.cs プロジェクト: rtxlab/ice
        public async ValueTask CloseAsync(Exception exception, CancellationToken cancel)
        {
            byte[] payload = new byte[2];
            short reason = System.Net.IPAddress.HostToNetworkOrder(
                (short)(exception is ObjectDisposedException ? ClosureStatusCode.Shutdown : ClosureStatusCode.Normal));
            MemoryMarshal.Write(payload, ref reason);

            _closing = true;

            // Send the close frame.
            await SendImplAsync(OpCode.Close, new List<ArraySegment<byte>> { payload }, cancel).ConfigureAwait(false);

            if (exception is ConnectionClosedByPeerException)
            {
                await ReceiveFrameAsync(cancel).ConfigureAwait(false);
            }
        }
コード例 #7
0
ファイル: SyscallTests.cs プロジェクト: fnsank/Pluto
        public void TestNtWriteVirtualMemory()
        {
            var syscall = new Syscall <Signatures.NtWriteVirtualMemory>();

            Span <byte> bytes = stackalloc byte[sizeof(int)];

            MemoryMarshal.Write(bytes, ref Unsafe.AsRef(_testValue));

            var status = syscall.Method(_process.SafeHandle, _testAddress, in bytes[0], bytes.Length, out _);

            if (status != NtStatus.Success)
            {
                throw new Win32Exception(Ntdll.RtlNtStatusToDosError(status));
            }

            Assert.Equal(_testValue, Marshal.ReadInt32(_testAddress));
        }
コード例 #8
0
        public void Add <TValue>(TKey key, TValue value)
            where TValue : unmanaged
        {
            if (ContainsKey(key))
            {
                throw new InvalidOperationException();
            }

            var size = typeof(TValue).IsEnum
                ? Marshal.SizeOf(Enum.GetUnderlyingType(typeof(TValue)))
                : Marshal.SizeOf(value);

            var storage = new byte[size];

            MemoryMarshal.Write(storage, ref value);
            _infos.Add(key, storage);
        }
コード例 #9
0
        public static void Write <T>(this Stream stream, ref T structure) where T : unmanaged
        {
#if FEATURE_NATIVE_SPAN
            if (sizeof(T) < MaxStackLimit)
            {
                Span <byte> stack = stackalloc byte[sizeof(T)];
                MemoryMarshal.Write(stack, ref structure);
                stream.Write(stack);
            }
            else
            {
                stream.Write(Struct.GetBytes(structure));
            }
#else
            stream.Write(Struct.GetBytes(structure));
#endif
        }
コード例 #10
0
        public static unsafe byte[] ToByteArray(List <SslApplicationProtocol> applicationProtocols)
        {
            long protocolListSize = 0;

            for (int i = 0; i < applicationProtocols.Count; i++)
            {
                int protocolLength = applicationProtocols[i].Protocol.Length;

                if (protocolLength == 0 || protocolLength > byte.MaxValue)
                {
                    throw new ArgumentException(SR.net_ssl_app_protocols_invalid, nameof(applicationProtocols));
                }

                protocolListSize += protocolLength + 1;

                if (protocolListSize > short.MaxValue)
                {
                    throw new ArgumentException(SR.net_ssl_app_protocols_invalid, nameof(applicationProtocols));
                }
            }

            Sec_Application_Protocols protocols = default;

            int protocolListConstSize = sizeof(Sec_Application_Protocols) - sizeof(uint) /* offsetof(Sec_Application_Protocols, ProtocolExtensionType) */;

            protocols.ProtocolListsSize = (uint)(protocolListConstSize + protocolListSize);

            protocols.ProtocolExtensionType = ApplicationProtocolNegotiationExt.ALPN;
            protocols.ProtocolListSize      = (short)protocolListSize;

            byte[] buffer = new byte[sizeof(Sec_Application_Protocols) + protocolListSize];
            int    index  = 0;

            MemoryMarshal.Write(buffer.AsSpan(index), ref protocols);
            index += sizeof(Sec_Application_Protocols);

            for (int i = 0; i < applicationProtocols.Count; i++)
            {
                ReadOnlySpan <byte> protocol = applicationProtocols[i].Protocol.Span;
                buffer[index++] = (byte)protocol.Length;
                protocol.CopyTo(buffer.AsSpan(index));
                index += protocol.Length;
            }

            return(buffer);
        }
コード例 #11
0
        public void GlobalSetup()
        {
            Span <byte> array = new byte[Constants.PAGE_ADDRESS_SIZE * Count];

            _pageAddresses = new PageAddress[Count];

            Random random = new Random();

            for (int i = 0; i < Count; i++)
            {
                PageAddress address = new PageAddress((uint)random.Next(0, int.MaxValue), (byte)random.Next(0, byte.MaxValue));
                _pageAddresses[i] = address;
                MemoryMarshal.Write(array.Slice((i * Constants.PAGE_ADDRESS_SIZE)), ref address);
            }

            _array = array.ToArray();
        }
コード例 #12
0
        private void BuildImportAddressTable()
        {
            if (_peImage.ImportDescriptors.Count == 0)
            {
                return;
            }

            foreach (var importDescriptor in _peImage.ImportDescriptors)
            {
                foreach (var function in importDescriptor.Functions)
                {
                    IntPtr functionAddress;

                    if (function.Name.Equals(string.Empty))
                    {
                        // Find the module that the function is exported from in the remote process

                        var functionModule = _processManager.Modules.First(module => module.Name.Equals(importDescriptor.Name, StringComparison.OrdinalIgnoreCase));

                        // Determine the name of the function using its ordinal

                        var functionName = functionModule.PeImage.Value.ExportedFunctions.First(exportedFunction => exportedFunction.Ordinal == function.Ordinal).Name;

                        functionAddress = _processManager.GetFunctionAddress(importDescriptor.Name, functionName);
                    }

                    else
                    {
                        functionAddress = _processManager.GetFunctionAddress(importDescriptor.Name, function.Name);
                    }

                    // Write the function address into the import address table in the local process

                    if (_processManager.IsWow64)
                    {
                        MemoryMarshal.Write(_dllBytes.Slice(function.Offset).Span, ref Unsafe.AsRef(functionAddress.ToInt32()));
                    }

                    else
                    {
                        MemoryMarshal.Write(_dllBytes.Slice(function.Offset).Span, ref Unsafe.AsRef(functionAddress.ToInt64()));
                    }
                }
            }
        }
コード例 #13
0
        internal static byte[] CreateRawMessageBody(MultiArray <byte> message, Guid correlationId, string name)
        {
            var nameLength = Encoding.GetByteCount(name);
            var body       = new byte[16 + 4 + nameLength + message.Count];
            var bodySpan   = body.AsSpan();

#if COMPATIBILITY
            correlationId.ToByteArray().CopyTo(body, 0);
            MemoryMarshal.Write(bodySpan.Slice(16, 4), ref nameLength);
            Encoding.GetBytes(name).CopyTo(bodySpan.Slice(20, nameLength));
#else
            correlationId.TryWriteBytes(bodySpan.Slice(0, 16));
            BitConverter.TryWriteBytes(bodySpan.Slice(16, 4), nameLength);
            Encoding.GetBytes(name, bodySpan.Slice(20, nameLength));
#endif
            message.CopyTo(body, 20 + nameLength);
            return(body);
        }
コード例 #14
0
        /// <summary>
        /// Write a <see cref="StringHeader"/> to a memory span
        /// </summary>
        /// <param name="to">Destination</param>
        /// <param name="data">String data</param>
        /// <returns>Number of bytes written</returns>
        public static int WriteStringRequest(Span <byte> to, string data)
        {
            Span <byte> unicodeData = Encoding.UTF8.GetBytes(data);

            // Write header
            StringHeader request = new StringHeader
            {
                Length = (ushort)unicodeData.Length
            };

            MemoryMarshal.Write(to, ref request);
            int bytesWritten = Marshal.SizeOf(request);

            // Write data
            unicodeData.CopyTo(to.Slice(bytesWritten));
            bytesWritten += unicodeData.Length;
            return(AddPadding(to, bytesWritten));
        }
コード例 #15
0
ファイル: SegmentBuilder.cs プロジェクト: veikkoeeva/orleans
        /// <summary>
        /// Appends a <see cref="ReadOnlyMemory{T}"/> of bytes to the end of the segment
        /// </summary>
        /// <param name="writerOffset"></param>
        /// <param name="bytes"></param>
        /// <param name="segment"></param>
        public static void Append(ArraySegment <byte> segment, ref int writerOffset, ReadOnlyMemory <byte> bytes)
        {
            if (segment.Array == null)
            {
                throw new ArgumentNullException(nameof(segment));
            }

            var length = bytes.Length;

            MemoryMarshal.Write(segment.AsSpan(writerOffset), ref length);
            writerOffset += sizeof(int);

            if (bytes.Length > 0)
            {
                bytes.CopyTo(segment.AsMemory(writerOffset));
                writerOffset += bytes.Length;
            }
        }
コード例 #16
0
        /// <summary>
        /// Write a request to evaluate an expression
        /// </summary>
        /// <param name="to">Destination</param>
        /// <param name="channel">Where to evaluate the expression</param>
        /// <param name="expression">Expression to evaluate</param>
        /// <returns>Number of bytes written</returns>
        public static int WriteEvaluateExpression(Span <byte> to, CodeChannel channel, string expression)
        {
            Span <byte> unicodeExpression = Encoding.UTF8.GetBytes(expression);

            // Write header
            CodeChannelHeader header = new CodeChannelHeader
            {
                Channel = channel
            };

            MemoryMarshal.Write(to, ref header);
            int bytesWritten = Marshal.SizeOf(header);

            // Write expression
            unicodeExpression.CopyTo(to.Slice(bytesWritten));
            bytesWritten += unicodeExpression.Length;
            return(AddPadding(to, bytesWritten));
        }
コード例 #17
0
ファイル: LibraryMapper.cs プロジェクト: raystyle/Lunar
        private void BuildImportAddressTable()
        {
            var importDescriptors = _peImage.ImportDirectory.Value.ImportDescriptors.Concat(_peImage.DelayImportDirectory.Value.DelayImportDescriptors);

            foreach (var importDescriptor in importDescriptors)
            {
                var importDescriptorName = _processManager.ResolveDllName(importDescriptor.Name);

                foreach (var function in importDescriptor.Functions)
                {
                    // Write the function address into the import address table

                    var functionAddress = function.Name is null?_processManager.GetFunctionAddress(importDescriptorName, function.Ordinal) : _processManager.GetFunctionAddress(importDescriptorName, function.Name);

                    MemoryMarshal.Write(_dllBytes.Slice(function.Offset).Span, ref functionAddress);
                }
            }
        }
コード例 #18
0
        /// <summary>
        ///     Compresses a stream into a .gz stream.
        /// </summary>
        /// <param name="data"></param>
        /// <param name="options"></param>
        /// <returns></returns>
        public static Span <byte> Compress(Span <byte> data, CompressionOptions?options)
        {
            options ??= CompressionOptions.Default;
            var buffer = new Span <byte>(new byte[data.Length]);
            var cursor = 0;

            for (var i = 0; i < data.Length; i += options.BlockSize)
            {
                using var ms            = new MemoryStream(options.BlockSize);
                using var deflateStream = new DeflateStream(ms, CompressionLevel.Optimal);

                var block = data.Slice(i, Math.Min(options.BlockSize, data.Length - i));
                deflateStream.Write(block);
                deflateStream.Flush();
                var write      = block.Length;
                var compressed = false;
                if (0x100 < block.Length) // special case where the last block is too small to compress properly.
                {
                    write       = (int)ms.Position + 2;
                    block       = new Span <byte>(new byte[ms.Length]);
                    ms.Position = 0;
                    ms.Read(block);
                    compressed = true;
                }

                var absWrite = write;
                if (compressed)
                {
                    absWrite = write + 0x4000;
                }

                MemoryMarshal.Write(buffer.Slice(cursor), ref absWrite);
                if (compressed)
                {
                    buffer[cursor + 4] = 0x78;
                    buffer[cursor + 5] = 0xDA;
                }

                block.CopyTo(buffer.Slice(cursor + 4 + (compressed ? 2 : 0)));
                cursor = (cursor + write + 4 + (compressed ? 2 : 0)).Align(0x80);
            }

            return(buffer.Slice(0, cursor));
        }
コード例 #19
0
        /// <summary>
        ///     Rebuild multi streams as individual streams
        /// </summary>
        /// <returns></returns>
        public List <Memory <byte> > ReconstructAsIndividual()
        {
            switch (Header.Streams)
            {
            case 0:
                return(new List <Memory <byte> >());

            case 1:
                return(new List <Memory <byte> >
                {
                    FullBuffer
                });
            }

            var header = Header;

            header.Streams             = 1;
            header.Unknown2            = -1;
            header.Unknown3            = 0;
            header.ADPCMSize           = SizeHelper.SizeOf <GCADPCMSoundInfo>();
            header.ADPCMPointer        = 0x38;
            header.PointerTablePointer = 0x98;
            header.SizeTablePointer    = 0x9C;

            var buffers = new List <Memory <byte> >();

            for (var index = 0; index < AudioBuffers.Count; index++)
            {
                var buffer = AudioBuffers[index];
                var data   = new Memory <byte>(new byte[(0xA0 + buffer.Length).Align(0x10)]);
                var @base  = header.Base;
                @base.Size  = data.Length;
                header.Base = @base;
                MemoryMarshal.Write(data.Span, ref header);
                var info = Table[index];
                MemoryMarshal.Write(data.Span.Slice(header.ADPCMPointer), ref info);
                BinaryPrimitives.WriteUInt32LittleEndian(data.Span.Slice(header.PointerTablePointer), 0xA0);
                BinaryPrimitives.WriteUInt32LittleEndian(data.Span.Slice(header.SizeTablePointer), (uint)buffer.Length);
                buffer.CopyTo(data.Slice(0xA0));
                buffers.Add(data);
            }

            return(buffers);
        }
コード例 #20
0
        private void BuildImportAddressTable()
        {
            Parallel.ForEach(_peImage.ImportDirectory.GetImportDescriptors(), importDescriptor =>
            {
                foreach (var function in importDescriptor.Functions)
                {
                    // Write the address of the function into the import address table

                    var functionAddress = function.Name is null ? _processContext.GetFunctionAddress(importDescriptor.Name, function.Ordinal) : _processContext.GetFunctionAddress(importDescriptor.Name, function.Name);

                    if (functionAddress == IntPtr.Zero)
                    {
                        throw new ApplicationException("Failed to resolve the address of a function in a module");
                    }

                    MemoryMarshal.Write(_dllBytes.Span.Slice(function.Offset), ref functionAddress);
                }
            });
        }
コード例 #21
0
        public unsafe static void ZeroFill(Span <byte> buff)
        {
            int num = 0;
            int i;

            for (i = 0; i < buff.Length / 4; i++)
            {
                MemoryMarshal.Write <int>(buff, ref num);
            }
            if (buff.Length % 4 == 0)
            {
                return;
            }
            while (i < buff.Length)
            {
                *buff[i] = 0;
                i++;
            }
        }
コード例 #22
0
        public async Task WriteParitionTableAsync(Stream diskStream, long diskLength)
        {
            MbrHeader header = MemoryMarshal.Cast <byte, MbrHeader>(new ReadOnlySpan <byte>(mHeader))[0];

            fixupPartitionEntry(ref header.Partition1, diskLength);
            fixupPartitionEntry(ref header.Partition2, diskLength);
            fixupPartitionEntry(ref header.Partition3, diskLength);
            fixupPartitionEntry(ref header.Partition4, diskLength);

            var headerBytes = new byte[MBR_SIZE];

            MemoryMarshal.Write(new Span <byte>(headerBytes), ref header);

            //var headerBytes = MemoryMarshal.Write
            diskStream.Seek(0, SeekOrigin.Begin);
            await diskStream.WriteAsync(headerBytes, 0, headerBytes.Length);

            await diskStream.FlushAsync();
        }
コード例 #23
0
 /// <summary>
 /// Writes a <see cref="System.UInt64"/> value.
 /// </summary>
 /// <param name="value">Value to write.</param>
 /// <param name="writer">Buffer writer to write the value to.</param>
 internal void WritePrimitive_UInt64(ulong value, IBufferWriter <byte> writer)
 {
     if (SerializationOptimization == SerializationOptimization.Speed || !IsLeb128EncodingMoreEfficient(value))
     {
         // use native encoding
         var buffer = writer.GetSpan(9);
         buffer[0] = (byte)PayloadType.UInt64_Native;
         MemoryMarshal.Write(buffer.Slice(1), ref value);
         writer.Advance(9);
     }
     else
     {
         // use LEB128 encoding
         var buffer = writer.GetSpan(1 + Leb128EncodingHelper.MaxBytesFor64BitValue);
         buffer[0] = (byte)PayloadType.UInt64_LEB128;
         int count = Leb128EncodingHelper.Write(buffer.Slice(1), value);
         writer.Advance(1 + count);
     }
 }
コード例 #24
0
        /// <summary>
        /// Write a <see cref="MessageHeader"/> to a memory span
        /// </summary>
        /// <param name="to">Destination</param>
        /// <param name="type">Message flags</param>
        /// <param name="message">Message content</param>
        /// <returns>Number of bytes written</returns>
        public static int WriteMessage(Span <byte> to, MessageTypeFlags type, string message)
        {
            Span <byte> unicodeMessage = Encoding.UTF8.GetBytes(message);

            // Write header
            MessageHeader request = new MessageHeader
            {
                MessageType = type,
                Length      = (ushort)unicodeMessage.Length
            };

            MemoryMarshal.Write(to, ref request);
            int bytesWritten = Marshal.SizeOf(request);

            // Write data
            unicodeMessage.CopyTo(to.Slice(bytesWritten));
            bytesWritten += unicodeMessage.Length;
            return(AddPadding(to, bytesWritten));
        }
コード例 #25
0
        internal async Task UpdateImageFileDirectoryNextOffsetFieldAsync(TiffStreamOffset target, TiffStreamOffset ifdOffset, CancellationToken cancellationToken)
        {
            EnsureNotDisposed();

            Debug.Assert(_writer != null);
            Debug.Assert(_operationContext != null);

            // Attemps to read 8 bytes even though the size of IFD may be less then 8 bytes.
            byte[] buffer = ArrayPool <byte> .Shared.Rent(SmallBufferSize);

            try
            {
                int rwCount = await _writer !.ReadAsync(target, new ArraySegment <byte>(buffer, 0, 8), cancellationToken).ConfigureAwait(false);
                if (!(_useBigTiff && rwCount == 8) && !(!_useBigTiff && rwCount >= 4))
                {
                    throw new InvalidDataException();
                }
                int count = ParseImageFileDirectoryCount(buffer.AsSpan(0, 8));

                // Prepare next ifd.
                if (_useBigTiff)
                {
                    rwCount = 8;
                    long offset = ifdOffset;
                    MemoryMarshal.Write(buffer, ref offset);
                }
                else
                {
                    rwCount = 4;
                    int offset32 = (int)ifdOffset;
                    MemoryMarshal.Write(buffer, ref offset32);
                }

                // Skip over IFD entries.
                int entryFieldLength = _useBigTiff ? 20 : 12;
                await _writer.WriteAsync(target + _operationContext !.ByteCountOfImageFileDirectoryCountField + count *entryFieldLength, new ArraySegment <byte>(buffer, 0, rwCount), cancellationToken).ConfigureAwait(false);
            }
            finally
            {
                ArrayPool <byte> .Shared.Return(buffer);
            }
        }
コード例 #26
0
        /// <summary>
        ///     Rebuild multi streams as individual streams
        /// </summary>
        /// <returns></returns>
        public List <Memory <byte> > ReconstructAsIndividual()
        {
            switch (Header.Streams)
            {
            case 0:
                return(new List <Memory <byte> >());

            case 1:
                return(new List <Memory <byte> >
                {
                    FullBuffer
                });
            }

            var header = Header;

            header.Streams             = 1;
            header.Unknown2            = -1;
            header.Unknown3            = 0;
            header.ADPCMSize           = 4;
            header.ADPCMPointer        = 0x38;
            header.PointerTablePointer = 0x3C;
            header.SizeTablePointer    = 0x40;

            var buffers = new List <Memory <byte> >();

            foreach (var buffer in AudioBuffers)
            {
                var data  = new Memory <byte>(new byte[(0x50 + buffer.Length).Align(0x10)]);
                var @base = header.Base;
                @base.Size  = data.Length;
                header.Base = @base;
                MemoryMarshal.Write(data.Span, ref header);
                BinaryPrimitives.WriteInt32LittleEndian(data.Span.Slice(header.ADPCMPointer), Header.SampleRate);
                BinaryPrimitives.WriteUInt32LittleEndian(data.Span.Slice(header.PointerTablePointer), 0x50);
                BinaryPrimitives.WriteUInt32LittleEndian(data.Span.Slice(header.SizeTablePointer), (uint)buffer.Length);
                buffer.CopyTo(data.Slice(0x50));
                buffers.Add(data);
            }

            return(buffers);
        }
コード例 #27
0
        /// <summary>
        /// Write a parsed G/M/T code in binary format to a memory span
        /// </summary>
        /// <param name="to">Destination</param>
        /// <param name="code">Code to write</param>
        /// <returns>Number of bytes written</returns>
        /// <exception cref="ArgumentException">Unsupported data type</exception>
        public static int WriteCode(Span <byte> to, Code code)
        {
            int bytesWritten = 0;

            // Write code header
            CodeHeader header = new()
            {
                Channel       = code.Channel,
                FilePosition  = (uint)(code.FilePosition ?? 0xFFFFFFFF),
                Letter        = (byte)code.Type,
                MajorCode     = (code.Type == CodeType.Comment) ? 0 : (code.MajorNumber ?? -1),
                MinorCode     = code.MinorNumber ?? -1,
                NumParameters = (byte)((code.Type == CodeType.Comment) ? 1 : code.Parameters.Count)
            };

            if (code.Type == CodeType.Comment || code.MajorNumber != null)
            {
                header.Flags |= CodeFlags.HasMajorCommandNumber;
            }
            if (code.MinorNumber != null)
            {
                header.Flags |= CodeFlags.HasMinorCommandNumber;
            }
            if (code.FilePosition != null)
            {
                header.Flags |= CodeFlags.HasFilePosition;
            }
            if (code.Flags.HasFlag(DuetAPI.Commands.CodeFlags.EnforceAbsolutePosition))
            {
                header.Flags |= CodeFlags.EnforceAbsolutePosition;
            }

            MemoryMarshal.Write(to, ref header);
            bytesWritten += Marshal.SizeOf <CodeHeader>();

            // Write line number
            if (DataTransfer.ProtocolVersion >= 2)
            {
                int lineNumber = (int)(code.LineNumber ?? 0);
                MemoryMarshal.Write(to[bytesWritten..], ref lineNumber);
                bytesWritten += Marshal.SizeOf <int>();
            }
コード例 #28
0
        public byte[] ToBytes(bool writeDecryptedKey)
        {
            uint magic = Magic;
            long size  = Size;

            byte[] key1 = writeDecryptedKey ? DecryptedKey1 : EncryptedKey1;
            byte[] key2 = writeDecryptedKey ? DecryptedKey2 : EncryptedKey2;

            var data = new byte[0x80];

            Array.Copy(Signature, data, 0x20);
            MemoryMarshal.Write(data.AsSpan(0x20), ref magic);

            Array.Copy(key1, 0, data, 0x28, 0x10);
            Array.Copy(key2, 0, data, 0x38, 0x10);

            MemoryMarshal.Write(data.AsSpan(0x48), ref size);

            return(data);
        }
コード例 #29
0
            internal void Append(JsonTokenType tokenType, int startLocation, int length)
            {
                // StartArray or StartObject should have length -1, otherwise the length should not be -1.
                Debug.Assert(
                    (tokenType == JsonTokenType.StartArray || tokenType == JsonTokenType.StartObject) ==
                    (length == DbRow.UnknownSize));

#if DEBUG
                Debug.Assert(!_isLocked, "Appending to a locked database");
#endif

                if (Length >= _data.Length - DbRow.Size)
                {
                    Enlarge();
                }

                DbRow row = new DbRow(tokenType, startLocation, length);
                MemoryMarshal.Write(_data.AsSpan(Length), ref row);
                Length += DbRow.Size;
            }
コード例 #30
0
        /// <summary>
        /// Write a file chunk
        /// </summary>
        /// <param name="to">Destination</param>
        /// <param name="data">File chunk data</param>
        /// <param name="fileLength">Total length of the file in bytes</param>
        /// <returns>Number of bytes written</returns>
        public static int WriteFileChunk(Span <byte> to, Span <byte> data, long fileLength)
        {
            // Write header
            FileChunk header = new FileChunk
            {
                DataLength = (data != null) ? data.Length : -1,
                FileLength = (uint)fileLength
            };

            MemoryMarshal.Write(to, ref header);
            int bytesWritten = Marshal.SizeOf(header);

            // Write chunk
            if (data != null)
            {
                data.CopyTo(to.Slice(bytesWritten));
                bytesWritten += data.Length;
            }
            return(AddPadding(to, bytesWritten));
        }