public SlurpBlock ( byte block, int offset, int count ) : void | ||
block | byte | block of bytes to slurp |
offset | int | starting point in the block |
count | int | how many bytes within the block to slurp |
Résultat | void |
/// <summary> /// Read from the stream /// </summary> /// <param name="buffer">the buffer to read</param> /// <param name="offset">the offset at which to start</param> /// <param name="count">the number of bytes to read</param> /// <returns>the number of bytes actually read</returns> public override int Read(byte[] buffer, int offset, int count) { int bytesToRead = count; // Need to limit the # of bytes returned, if the stream is intended to have // a definite length. This is especially useful when returning a stream for // the uncompressed data directly to the application. The app won't // necessarily read only the UncompressedSize number of bytes. For example // wrapping the stream returned from OpenReader() into a StreadReader() and // calling ReadToEnd() on it, We can "over-read" the zip data and get a // corrupt string. The length limits that, prevents that problem. if (_lengthLimit != UnsetLengthLimit) { if (_Crc32.TotalBytesRead >= _lengthLimit) { return(0); // EOF } var bytesRemaining = _lengthLimit - _Crc32.TotalBytesRead; if (bytesRemaining < count) { bytesToRead = (int)bytesRemaining; } } int n = _innerStream.Read(buffer, offset, bytesToRead); if (n > 0) { _Crc32.SlurpBlock(buffer, offset, n); } return(n); }
public byte[] Encode() { using (var memoryStream = new MemoryStream()) { using (var binaryWriter = new BinaryWriter(memoryStream)) { // https://core.telegram.org/mtproto#tcp-transport /* 4 length bytes are added at the front (to include the length, the sequence number, and CRC32; always divisible by 4) and 4 bytes with the packet sequence number within this TCP connection (the first packet sent is numbered 0, the next one 1, etc.), and 4 CRC32 bytes at the end (length, sequence number, and payload together). */ binaryWriter.Write(Body.Length + 12); binaryWriter.Write(SequneceNumber); binaryWriter.Write(Body); var crc32 = new CRC32(); crc32.SlurpBlock(memoryStream.GetBuffer(), 0, 8 + Body.Length); binaryWriter.Write(crc32.Crc32Result); var transportPacket = memoryStream.ToArray(); // Debug.WriteLine("Tcp packet #{0}\n{1}", SequneceNumber, BitConverter.ToString(transportPacket)); return transportPacket; } } }
public static TcpMessage Decode(byte[] body) { if (body == null) throw new ArgumentNullException(nameof(body)); if (body.Length < 12) throw new InvalidOperationException("Ops, wrong size of input packet"); using (var memoryStream = new MemoryStream(body)) { using (var binaryReader = new BinaryReader(memoryStream)) { var packetLength = binaryReader.ReadInt32(); if (packetLength < 12) throw new InvalidOperationException(string.Format("invalid packet length: {0}", packetLength)); var seq = binaryReader.ReadInt32(); byte[] packet = binaryReader.ReadBytes(packetLength - 12); var checksum = (int)binaryReader.ReadInt32(); var crc32 = new CRC32(); crc32.SlurpBlock(body, 0, packetLength - 4); var validChecksum = crc32.Crc32Result; if (checksum != validChecksum) { throw new InvalidOperationException("invalid checksum! skip"); } return new TcpMessage(seq, packet); } } }
private static async Task <TcpMessage> Receieve(TcpClient tcpClient) { var stream = tcpClient.GetStream(); var packetLengthBytes = new byte[4]; if (await stream.ReadAsync(packetLengthBytes, 0, 4) != 4) { throw new InvalidOperationException("Couldn't read the packet length"); } int packetLength = BitConverter.ToInt32(packetLengthBytes, 0); var seqBytes = new byte[4]; if (await stream.ReadAsync(seqBytes, 0, 4) != 4) { throw new InvalidOperationException("Couldn't read the sequence"); } int seq = BitConverter.ToInt32(seqBytes, 0); int readBytes = 0; var body = new byte[packetLength - 12]; int neededToRead = packetLength - 12; do { var bodyByte = new byte[packetLength - 12]; var availableBytes = await stream.ReadAsync(bodyByte, 0, neededToRead); neededToRead -= availableBytes; Buffer.BlockCopy(bodyByte, 0, body, readBytes, availableBytes); readBytes += availableBytes; }while (readBytes != packetLength - 12); var crcBytes = new byte[4]; if (await stream.ReadAsync(crcBytes, 0, 4) != 4) { throw new InvalidOperationException("Couldn't read the crc"); } int checksum = BitConverter.ToInt32(crcBytes, 0); byte[] rv = new byte[packetLengthBytes.Length + seqBytes.Length + body.Length]; Buffer.BlockCopy(packetLengthBytes, 0, rv, 0, packetLengthBytes.Length); Buffer.BlockCopy(seqBytes, 0, rv, packetLengthBytes.Length, seqBytes.Length); Buffer.BlockCopy(body, 0, rv, packetLengthBytes.Length + seqBytes.Length, body.Length); var crc32 = new Ionic.Crc.CRC32(); crc32.SlurpBlock(rv, 0, rv.Length); var validChecksum = crc32.Crc32Result; if (checksum != validChecksum) { throw new InvalidOperationException("invalid checksum! skip"); } return(new TcpMessage(seq, body)); }
public override int Read(byte[] buffer, int offset, int count) { int bytesToRead = count; if (_lengthLimit != UnsetLengthLimit) { if (_Crc32.TotalBytesRead >= _lengthLimit) { return(0); } long bytesRemaining = _lengthLimit - _Crc32.TotalBytesRead; if (bytesRemaining < count) { bytesToRead = (int)bytesRemaining; } } int i = _innerStream.Read(buffer, offset, bytesToRead); if (i > 0) { _Crc32.SlurpBlock(buffer, offset, i); } return(i); }
public override int Read(byte[] buffer, int offset, int count) { int count2 = count; if (_lengthLimit != UnsetLengthLimit) { if (_crc32.TotalBytesRead >= _lengthLimit) { return(0); } long num = _lengthLimit - _crc32.TotalBytesRead; if (num < count) { count2 = (int)num; } } int num2 = _innerStream.Read(buffer, offset, count2); if (num2 > 0) { _crc32.SlurpBlock(buffer, offset, num2); } return(num2); }
public int Crc32(int currentReadPositionOffset, int length) { //Crc32 crc32 = new Crc32(); //logger.info("calc crc32 offset {0}, length {1} on: {2}", currentReadPositionOffset, length, BitConverter.ToString(buffer, readIndex + currentReadPositionOffset, length)); //return crc32.ComputeHash(buffer, readIndex + currentReadPositionOffset, length).Reverse().ToArray(); CRC32 crc32 = new CRC32(); crc32.SlurpBlock(buffer, readIndex+currentReadPositionOffset, length); return crc32.Crc32Result; }
public async Task Send(byte[] packet) { AsyncSocket socketToSend; logger.debug("transport send..."); lock (this) { if (socket == null) { logger.debug("socket == null"); throw new MTProtoTransportException("not connected"); } logger.debug("socket != null"); socketToSend = socket; } try { using (MemoryStream memoryStream = new MemoryStream()) { using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream)) { CRC32 crc32 = new CRC32(); binaryWriter.Write(packet.Length + 12); binaryWriter.Write(Interlocked.Increment(ref sendCounter) - 1); binaryWriter.Write(packet); crc32.SlurpBlock(memoryStream.GetBuffer(), 0, 8 + packet.Length); binaryWriter.Write(crc32.Crc32Result); logger.debug("sending to socket: {0}", BitConverter.ToString(memoryStream.GetBuffer(), 0, (int) memoryStream.Position).Replace("-","").ToLower()); await socketToSend.Send(memoryStream.GetBuffer(), 0, (int) memoryStream.Position); } } } catch (Exception e) { throw new MTProtoTransportException("unable to send packet", e); } }
public bool TransportSend(byte[] packet) { //logger.debug("network send packet"); lock (this) { if (state != NetworkGatewayState.ESTABLISHED) { logger.warning("send error, state not established"); return false; } using (MemoryStream memoryStream = new MemoryStream()) { using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream)) { //Crc32 crc32 = new Crc32(); CRC32 crc32 = new CRC32(); binaryWriter.Write(packet.Length + 12); binaryWriter.Write(sendCounter); binaryWriter.Write(packet); crc32.SlurpBlock(memoryStream.GetBuffer(), 0, 8+packet.Length); binaryWriter.Write(crc32.Crc32Result); byte[] transportPacket = memoryStream.ToArray(); //logger.info("send transport packet: {0}", BitConverter.ToString(transportPacket).Replace("-","")); var args = new SocketAsyncEventArgs(); args.SetBuffer(transportPacket, 0, transportPacket.Length); try { socket.SendAsync(args); } catch (Exception e) { logger.warning("transport packet send error: {0}", e); /* if(state != NetworkGatewayState.DISPOSED) { state = NetworkGatewayState.INIT; Connect(host, port); }*/ TryReconnect(); return false; } sendCounter++; return true; } } } }