Example #1
0
		public Record (Socket socket, Buffers receive_buffer) : this()
		{
			if (socket == null)
				throw new ArgumentNullException ("socket");

			CompatArraySegment<byte> header_buffer = receive_buffer.EnforceHeaderLength (HeaderSize);

			// Read the 8 byte record header.
			NRecord.ReceiveAll (socket, header_buffer, HeaderSize);

			// Read the values from the data.
			version        = header_buffer [0];
			type           = (RecordType) header_buffer [1];
			request_id     = NRecord.ReadUInt16 (header_buffer, 2);
			BodyLength     = NRecord.ReadUInt16 (header_buffer, 4);
			byte padding_length = header_buffer [6];

			CompatArraySegment<byte> body_buffer  = receive_buffer.EnforceBodyLength (BodyLength);

			// Read the record data, and throw an exception if the
			// complete data cannot be read.
			if (BodyLength > 0)
				NRecord.ReceiveAll (socket, body_buffer, BodyLength);

			CompatArraySegment<byte> padding_buffer = receive_buffer.EnforcePaddingLength (padding_length);

			if(padding_length > 0)
				NRecord.ReceiveAll(socket, padding_buffer, padding_length);

			buffers = receive_buffer;

			Logger.Write (LogLevel.Debug, Strings.Record_Received, Type, RequestID, BodyLength);
		}
Example #2
0
        public void Send(Socket socket)
        {
            var padding_size = (byte)((8 - (BodyLength % 8)) % 8);

            CompatArraySegment <byte> header = Content.EnforceHeaderLength(HEADER_SIZE);

            header [0] = Version;
            header [1] = (byte)Type;
            header [2] = (byte)(RequestID >> 8);
            header [3] = (byte)(RequestID & 0xFF);
            header [4] = (byte)(BodyLength >> 8);
            header [5] = (byte)(BodyLength & 0xFF);
            header [6] = padding_size;

            CompatArraySegment <byte> padding = Content.EnforcePaddingLength(padding_size);

            for (int i = 0; i < padding_size; i++)
            {
                padding [i] = 0;
            }

            Logger.Write(LogLevel.Debug, Strings.Record_Sent, Type, RequestID, BodyLength);

            SendAll(socket, header, HEADER_SIZE);
            SendAll(socket, Content.Body, BodyLength);
            SendAll(socket, padding, padding_size);
        }
Example #3
0
		public static Record Receive (Socket socket, Buffers buffers)
		{
			if (socket == null)
				throw new ArgumentNullException ("socket");

			CompatArraySegment<byte> header_buffer = buffers.EnforceHeaderLength (HEADER_SIZE);

			// Read the 8 byte record header.
			ReceiveAll (socket, header_buffer, HEADER_SIZE);

			// Read the values from the data.
			var version         = header_buffer [0];
			var type            = (RecordType) header_buffer [1];
			var requestID       = ReadUInt16 (header_buffer, 2);
			var bodyLength      = ReadUInt16 (header_buffer, 4);
			byte padding_length = header_buffer [6];

			CompatArraySegment<byte> body_buffer  = buffers.EnforceBodyLength (bodyLength);

			// Read the record data, and throw an exception if the
			// complete data cannot be read.
			if (bodyLength > 0)
				ReceiveAll (socket, body_buffer, bodyLength);

			CompatArraySegment<byte> padding_buffer = buffers.EnforcePaddingLength (padding_length);

			if(padding_length > 0)
				ReceiveAll(socket, padding_buffer, padding_length);

			Logger.Write (LogLevel.Debug, Strings.Record_Received, type, requestID, bodyLength);

			return new Record (version, type, requestID, bodyLength, buffers);
		}
Example #4
0
        public static Record Receive(Socket socket, Buffers buffers)
        {
            if (socket == null)
            {
                throw new ArgumentNullException("socket");
            }

            CompatArraySegment <byte> header_buffer = buffers.EnforceHeaderLength(HEADER_SIZE);

            // Read the 8 byte record header.
            ReceiveAll(socket, header_buffer, HEADER_SIZE);

            // Read the values from the data.
            var  version        = header_buffer [0];
            var  type           = (RecordType)header_buffer [1];
            var  requestID      = ReadUInt16(header_buffer, 2);
            var  bodyLength     = ReadUInt16(header_buffer, 4);
            byte padding_length = header_buffer [6];

            CompatArraySegment <byte> body_buffer = buffers.EnforceBodyLength(bodyLength);

            // Read the record data, and throw an exception if the
            // complete data cannot be read.
            if (bodyLength > 0)
            {
                ReceiveAll(socket, body_buffer, bodyLength);
            }

            CompatArraySegment <byte> padding_buffer = buffers.EnforcePaddingLength(padding_length);

            if (padding_length > 0)
            {
                ReceiveAll(socket, padding_buffer, padding_length);
            }

            Logger.Write(LogLevel.Debug, Strings.Record_Received, type, requestID, bodyLength);

            return(new Record(version, type, requestID, bodyLength, buffers));
        }