/// <summary> /// Writes a signed integer using 1 to 32 bits /// </summary> public void Write(Int32 source, int numberOfBits) { NetException.Assert((numberOfBits > 0 && numberOfBits <= 32), "Write(int, numberOfBits) can only write between 1 and 32 bits"); EnsureBufferSize(m_bitLength + numberOfBits); if (numberOfBits != 32) { // make first bit sign int signBit = 1 << (numberOfBits - 1); if (source < 0) { source = (-source - 1) | signBit; } else { source &= (~signBit); } } NetBitWriter.WriteUInt32((uint)source, numberOfBits, m_data, m_bitLength); m_bitLength += numberOfBits; }
/// <summary> /// Decrypt an incoming message encrypted with corresponding Encrypt /// </summary> /// <param name="msg">message to decrypt</param> /// <returns>true if successful; false if failed</returns> public override bool Decrypt(NetIncomingMessage msg) { int numEncryptedBytes = msg.LengthBytes - 4; // last 4 bytes is true bit length int blockSize = BlockSize; int numBlocks = numEncryptedBytes / blockSize; if (numBlocks * blockSize != numEncryptedBytes) { return(false); } for (int i = 0; i < numBlocks; i++) { DecryptBlock(msg.m_data, (i * blockSize), m_tmp); Buffer.BlockCopy(m_tmp, 0, msg.m_data, (i * blockSize), m_tmp.Length); } // read 32 bits of true payload length uint realSize = NetBitWriter.ReadUInt32(msg.m_data, 32, (numEncryptedBytes * 8)); msg.m_bitLength = (int)realSize; return(true); }
/// <summary> /// Reads the specified number of bits into a Byte without advancing the read pointer /// </summary> public byte PeekByte(int numberOfBits) { byte retval = NetBitWriter.ReadByte(m_data, numberOfBits, m_readPosition); return(retval); }
public static int WriteUInt64(ulong source, int numberOfBits, byte[] destination, int destinationBitOffset) { #if BIGENDIAN source = ((source & 0xff00000000000000L) >> 56) | ((source & 0x00ff000000000000L) >> 40) | ((source & 0x0000ff0000000000L) >> 24) | ((source & 0x000000ff00000000L) >> 8) | ((source & 0x00000000ff000000L) << 8) | ((source & 0x0000000000ff0000L) << 24) | ((source & 0x000000000000ff00L) << 40) | ((source & 0x00000000000000ffL) << 56); #endif int returnValue = destinationBitOffset + numberOfBits; if (numberOfBits <= 8) { NetBitWriter.WriteByte((byte)source, numberOfBits, destination, destinationBitOffset); return(returnValue); } NetBitWriter.WriteByte((byte)source, 8, destination, destinationBitOffset); destinationBitOffset += 8; numberOfBits -= 8; if (numberOfBits <= 8) { NetBitWriter.WriteByte((byte)(source >> 8), numberOfBits, destination, destinationBitOffset); return(returnValue); } NetBitWriter.WriteByte((byte)(source >> 8), 8, destination, destinationBitOffset); destinationBitOffset += 8; numberOfBits -= 8; if (numberOfBits <= 8) { NetBitWriter.WriteByte((byte)(source >> 16), numberOfBits, destination, destinationBitOffset); return(returnValue); } NetBitWriter.WriteByte((byte)(source >> 16), 8, destination, destinationBitOffset); destinationBitOffset += 8; numberOfBits -= 8; if (numberOfBits <= 8) { NetBitWriter.WriteByte((byte)(source >> 24), numberOfBits, destination, destinationBitOffset); return(returnValue); } NetBitWriter.WriteByte((byte)(source >> 24), 8, destination, destinationBitOffset); destinationBitOffset += 8; numberOfBits -= 8; if (numberOfBits <= 8) { NetBitWriter.WriteByte((byte)(source >> 32), numberOfBits, destination, destinationBitOffset); return(returnValue); } NetBitWriter.WriteByte((byte)(source >> 32), 8, destination, destinationBitOffset); destinationBitOffset += 8; numberOfBits -= 8; if (numberOfBits <= 8) { NetBitWriter.WriteByte((byte)(source >> 40), numberOfBits, destination, destinationBitOffset); return(returnValue); } NetBitWriter.WriteByte((byte)(source >> 40), 8, destination, destinationBitOffset); destinationBitOffset += 8; numberOfBits -= 8; if (numberOfBits <= 8) { NetBitWriter.WriteByte((byte)(source >> 48), numberOfBits, destination, destinationBitOffset); return(returnValue); } NetBitWriter.WriteByte((byte)(source >> 48), 8, destination, destinationBitOffset); destinationBitOffset += 8; numberOfBits -= 8; if (numberOfBits <= 8) { NetBitWriter.WriteByte((byte)(source >> 56), numberOfBits, destination, destinationBitOffset); return(returnValue); } NetBitWriter.WriteByte((byte)(source >> 56), 8, destination, destinationBitOffset); destinationBitOffset += 8; numberOfBits -= 8; return(returnValue); }
public byte[] PeekBytes(int numberOfBytes) { byte[] retval = new byte[numberOfBytes]; NetBitWriter.ReadBytes(Data, numberOfBytes, m_readPosition, retval, 0); return(retval); }
// // 8 bit // public byte PeekByte() { byte retval = NetBitWriter.ReadByte(Data, 8, m_readPosition); return(retval); }
public void Write(UInt64 source, int numberOfBits) { EnsureBufferSize(m_bitLength + numberOfBits); NetBitWriter.WriteUInt64(source, numberOfBits, m_data, m_bitLength); m_bitLength += numberOfBits; }
public void Write(UInt32 source) { EnsureBufferSize(m_bitLength + 32); NetBitWriter.WriteUInt32(source, 32, m_data, m_bitLength); m_bitLength += 32; }
internal void Write(Int32 source) { InternalEnsureBufferSize(m_bitLength + 32); NetBitWriter.WriteUInt32((UInt32)source, 32, m_data, m_bitLength); m_bitLength += 32; }
internal void Write(Int16 source) { InternalEnsureBufferSize(m_bitLength + 16); NetBitWriter.WriteUInt32((uint)source, 16, m_data, m_bitLength); m_bitLength += 16; }
/// <summary> /// Write a <see cref="byte"/>. /// </summary> public static void Write(this IBitBuffer buffer, byte value) { buffer.EnsureEnoughBitCapacity(8); NetBitWriter.WriteByte(value, 8, buffer.GetBuffer(), buffer.BitPosition); buffer.IncrementBitPosition(8); }
/// <summary> /// Writes a <see cref="bool"/> value using 1 bit. /// </summary> public static void WriteBit(this IBitBuffer buffer, bool value) { buffer.EnsureEnoughBitCapacity(1); NetBitWriter.WriteByte(value ? (byte)1 : (byte)0, 1, buffer.GetBuffer(), buffer.BitPosition); buffer.IncrementBitPosition(1); }
/// <summary> /// Writes a <see cref="byte"/> using 1 to 8 bits. /// </summary> public static void Write(this IBitBuffer buffer, byte source, int bitCount) { buffer.EnsureEnoughBitCapacity(bitCount, maxBitCount: 8); NetBitWriter.WriteByte(source, bitCount, buffer.GetBuffer(), buffer.BitPosition); buffer.IncrementBitPosition(bitCount); }
public static OperationStatus ReadVarUInt64(this IBitBuffer buffer, out ulong result) { return(NetBitWriter.ReadVarUInt64(buffer, peek: false, out result)); }
public static OperationStatus PeekVarUInt32(this IBitBuffer buffer, out uint result) { return(NetBitWriter.ReadVarUInt32(buffer, peek: true, out result)); }
public void Write(sbyte source) { EnsureBufferSize(m_bitLength + 8); NetBitWriter.WriteByte((byte)source, 8, m_data, m_bitLength); m_bitLength += 8; }
/// <summary> /// Writes a signed 16 bit integer /// </summary> public void Write(Int16 source) { EnsureBufferSize(m_bitLength + 16); NetBitWriter.WriteUInt16((ushort)source, 16, m_data, m_bitLength); m_bitLength += 16; }
// // 8 bit // internal void Write(byte source) { InternalEnsureBufferSize(m_bitLength + 8); NetBitWriter.WriteByte(source, 8, m_data, m_bitLength); m_bitLength += 8; }
public void Write(UInt64 source) { EnsureBufferSize(m_bitLength + 64); NetBitWriter.WriteUInt64(source, 64, m_data, m_bitLength); m_bitLength += 64; }
public UInt32 PeekUInt32() { uint retval = NetBitWriter.ReadUInt32(Data, 32, m_readPosition); return(retval); }
/// <summary> /// Writes a boolean value using 1 bit /// </summary> public void Write(bool value) { EnsureBufferSize(m_bitLength + 1); NetBitWriter.WriteByte((value ? (byte)1 : (byte)0), 1, m_data, m_bitLength); m_bitLength += 1; }
// // 1 bit // public bool PeekBoolean() { byte retval = NetBitWriter.ReadByte(Data, 1, m_readPosition); return(retval > 0 ? true : false); }