public int Read(byte[] buffer, int offset, int count) { var toread = Math.Min(count, BytesToRead); return(BaseStream.Read(buffer, offset, toread)); }
public byte[] ReadPacket() { byte[] buffer = new byte[260]; int count = 0; int length = 0; int readcount = 0; lastbad = new byte[2]; BaseStream.ReadTimeout = 1200; // 1200 ms between chars - the gps detection requires this. DateTime start = DateTime.Now; lock (readlock) { while (BaseStream.IsOpen) { try { if (readcount > 300) { //No valid mavlink package break; } readcount++; //MAV.cs.datetime = DateTime.Now; DateTime to = DateTime.Now.AddMilliseconds(BaseStream.ReadTimeout); // Console.WriteLine(DateTime.Now.Millisecond + " SR1a " + BaseStream.BytesToRead); while (BaseStream.IsOpen && BaseStream.BytesToRead <= 0) { if (DateTime.Now > to) { //log.InfoFormat("MAVLINK: 1 wait time out btr {0} len {1}", BaseStream.BytesToRead, length); throw new Exception("Timeout"); } System.Threading.Thread.Sleep(1); //Console.WriteLine(DateTime.Now.Millisecond + " SR0b " + BaseStream.BytesToRead); } if (BaseStream.IsOpen) { BaseStream.Read(buffer, count, 1); } } catch (Exception e) { break; } // check if looks like a mavlink packet and check for exclusions and write to console if (buffer[0] != 254) { if (buffer[0] >= 0x20 && buffer[0] <= 127 || buffer[0] == '\n' || buffer[0] == '\r') { // check for line termination if (buffer[0] == '\r' || buffer[0] == '\n') { // check new line is valid if (buildplaintxtline.Length > 3) { plaintxtline = buildplaintxtline; } // reset for next line buildplaintxtline = ""; } form.UpdateTextBox(((char)buffer[0]).ToString()); //TCPConsole.Write(buffer[0]); //Console.Write((char)buffer[0]); buildplaintxtline += (char)buffer[0]; } _bytesReceivedSubj.OnNext(1); count = 0; lastbad[0] = lastbad[1]; lastbad[1] = buffer[0]; buffer[1] = 0; continue; } // reset count on valid packet readcount = 0; // check for a header if (buffer[0] == 254) { if (count == 0) { DateTime to = DateTime.Now.AddMilliseconds(BaseStream.ReadTimeout); while (BaseStream.IsOpen && BaseStream.BytesToRead < 5) { if (DateTime.Now > to) { throw new Exception("Timeout"); } System.Threading.Thread.Sleep(1); } int read = BaseStream.Read(buffer, 1, 5); count = read; } // packet length length = buffer[1] + 6 + 2 - 2; // data + header + checksum - U - length if (count >= 5) { if (MAV.sysid != 0) { if (MAV.sysid != buffer[3] || MAV.compid != buffer[4]) { if (buffer[3] == '3' && buffer[4] == 'D') { // this is a 3dr radio rssi packet } else { //log.InfoFormat("Mavlink Bad Packet (not addressed to this MAV) got {0} {1} vs {2} {3}", buffer[3], buffer[4], MAV.sysid, MAV.compid); return(new byte[0]); } } } try { DateTime to = DateTime.Now.AddMilliseconds(BaseStream.ReadTimeout); while (BaseStream.IsOpen && BaseStream.BytesToRead < (length - 4)) { if (DateTime.Now > to) { //log.InfoFormat("MAVLINK: 3 wait time out btr {0} len {1}", BaseStream.BytesToRead, length); break; } System.Threading.Thread.Sleep(1); } if (BaseStream.IsOpen) { int read = BaseStream.Read(buffer, 6, length - 4); } count = length + 2; } catch { break; } break; } } count++; if (count == 299) { break; } } } // end readlock Array.Resize <byte>(ref buffer, count); _bytesReceivedSubj.OnNext(buffer.Length); if (packetlosttimer.AddSeconds(5) < DateTime.Now) { packetlosttimer = DateTime.Now; packetslost = (packetslost * 0.8f); packetsnotlost = (packetsnotlost * 0.8f); } if (bpstime.Second != DateTime.Now.Second && BaseStream.IsOpen) { Console.Write("bps {0} loss {1} left {2} mem {3} \n", bps1, synclost, BaseStream.BytesToRead, System.GC.GetTotalMemory(false) / 1024 / 1024.0); bps2 = bps1; // prev sec bps1 = 0; // current sec bpstime = DateTime.Now; } bps1 += buffer.Length; bps = (bps1 + bps2) / 2; ushort crc = MavlinkCRC.crc_calculate(buffer, buffer.Length - 2); if (buffer.Length > 5 && buffer[0] == 254) { crc = MavlinkCRC.crc_accumulate(MAVLINK_MESSAGE_CRCS[buffer[5]], crc); } if (buffer.Length > 5 && buffer[1] != MAVLINK_MESSAGE_LENGTHS[buffer[5]]) { if (MAVLINK_MESSAGE_LENGTHS[buffer[5]] == 0) // pass for unknown packets { } else { //log.InfoFormat("Mavlink Bad Packet (Len Fail) len {0} pkno {1}", buffer.Length, buffer[5]); if (buffer.Length == 11 && buffer[0] == 'U' && buffer[5] == 0) { string message = "Mavlink 0.9 Heartbeat, Please upgrade your AP, This planner is for Mavlink 1.0\n\n"; MessageBox.Show(message); throw new Exception(message); } return(new byte[0]); } } if (buffer.Length < 5 || buffer[buffer.Length - 1] != (crc >> 8) || buffer[buffer.Length - 2] != (crc & 0xff)) { int packetno = -1; if (buffer.Length > 5) { packetno = buffer[5]; } if (packetno != -1 && buffer.Length > 5 && MAVLINK_MESSAGE_INFO[packetno] != null) { //log.InfoFormat("Mavlink Bad Packet (crc fail) len {0} crc {1} vs {4} pkno {2} {3}", buffer.Length, crc, packetno, MAVLINK_MESSAGE_INFO[packetno].ToString(), BitConverter.ToUInt16(buffer, buffer.Length - 2)); form.UpdateTextBox("Mavlink Bad Packet."); } return(new byte[0]); } try { if ((buffer[0] == 'U' || buffer[0] == 254) && buffer.Length >= buffer[1]) { if (buffer[3] == '3' && buffer[4] == 'D') { // Do nothing } else { byte packetSeqNo = buffer[2]; int expectedPacketSeqNo = ((MAV.recvpacketcount + 1) % 0x100); if (packetSeqNo != expectedPacketSeqNo) { synclost++; // actualy sync loss's int numLost = 0; if (packetSeqNo < ((MAV.recvpacketcount + 1))) // recvpacketcount = 255 then 10 < 256 = true if was % 0x100 this would fail { numLost = 0x100 - expectedPacketSeqNo + packetSeqNo; } else { numLost = packetSeqNo - MAV.recvpacketcount; } packetslost += numLost; WhenPacketLost.OnNext(numLost); //log.InfoFormat("lost pkts new seqno {0} pkts lost {1}", packetSeqNo, numLost); } packetsnotlost++; MAV.recvpacketcount = packetSeqNo; WhenPacketReceived.OnNext(1); } if (double.IsInfinity(packetspersecond[buffer[5]])) { packetspersecond[buffer[5]] = 0; } packetspersecond[buffer[5]] = (((1000 / ((DateTime.Now - packetspersecondbuild[buffer[5]]).TotalMilliseconds) + packetspersecond[buffer[5]]) / 2)); packetspersecondbuild[buffer[5]] = DateTime.Now; lock (writelock) { MAV.packets[buffer[5]] = buffer; MAV.packetseencount[buffer[5]]++; } if (buffer[5] == (byte)MAVLink.MAVLINK_MSG_ID.STATUSTEXT) // status text { var msg = MAV.packets[(byte)MAVLink.MAVLINK_MSG_ID.STATUSTEXT].ByteArrayToStructure <MAVLink.mavlink_statustext_t>(6); byte sev = msg.severity; string logdata = Encoding.ASCII.GetString(msg.text); int ind = logdata.IndexOf('\0'); if (ind != -1) { logdata = logdata.Substring(0, ind); } //log.Info(DateTime.Now + " " + logdata); form.UpdateTextBox(logdata); //MAV.cs.messages.Add(logdata); if (sev >= 3) { } } // set ap type if (buffer[5] == (byte)MAVLink.MAVLINK_MSG_ID.HEARTBEAT) { mavlink_heartbeat_t hb = buffer.ByteArrayToStructure <mavlink_heartbeat_t>(6); if (hb.type != (byte)MAVLink.MAV_TYPE.GCS) { mavlinkversion = hb.mavlink_version; MAV.aptype = (MAV_TYPE)hb.type; MAV.apname = (MAV_AUTOPILOT)hb.autopilot; //setAPType(); } } } } catch { } if (buffer[3] == '3' && buffer[4] == 'D') { // dont update last packet time for 3dr radio packets } else { lastvalidpacket = DateTime.Now; } return(buffer); }
// TODO: How to know VxD structure offset void Initialize() { Recognized = false; if (BaseStream == null) { return; } BaseExecutable = new MZ(BaseStream); if (!BaseExecutable.Recognized) { return; } if (BaseExecutable.Header.new_offset >= BaseStream.Length) { return; } BaseStream.Seek(BaseExecutable.Header.new_offset, SeekOrigin.Begin); byte[] buffer = new byte[Marshal.SizeOf(typeof(LXHeader))]; BaseStream.Read(buffer, 0, buffer.Length); IntPtr hdrPtr = Marshal.AllocHGlobal(buffer.Length); Marshal.Copy(buffer, 0, hdrPtr, buffer.Length); Header = (LXHeader)Marshal.PtrToStructure(hdrPtr, typeof(LXHeader)); Marshal.FreeHGlobal(hdrPtr); Recognized = Header.signature == SIGNATURE || Header.signature == SIGNATURE16; if (!Recognized) { return; } Type = Header.signature == SIGNATURE16 ? "Linear Executable (LE)" : "Linear eXecutable (LX)"; IsBigEndian = Header.byte_order == 1 || Header.word_order == 1; List <string> strings = new List <string>(); OperatingSystem reqOs = new OperatingSystem(); switch (Header.os_type) { case TargetOS.OS2: reqOs.Name = "OS/2"; if (Header.module_flags.HasFlag(ModuleFlags.PMIncompatible) && !Header.module_flags.HasFlag(ModuleFlags.PMCompatible) || !Header.module_flags.HasFlag(ModuleFlags.PMIncompatible) && Header.module_flags.HasFlag(ModuleFlags.PMCompatible)) { reqOs.Subsystem = "Console"; } else if (Header.module_flags.HasFlag(ModuleFlags.PMIncompatible) && Header.module_flags.HasFlag(ModuleFlags.PMCompatible)) { reqOs.Subsystem = "Presentation Manager"; } break; case TargetOS.Windows: case TargetOS.Win32: case TargetOS.Unknown: reqOs.Name = "Windows"; break; case TargetOS.DOS: reqOs.Name = "Windows"; break; default: reqOs.Name = $"Unknown code {(ushort)Header.os_type}"; break; } RequiredOperatingSystem = reqOs; if (Header.resident_names_off != 0) { ResidentNames = GetResidentStrings(BaseStream, BaseExecutable.Header.new_offset, Header.resident_names_off); if (ResidentNames.Length >= 1) { ModuleName = ResidentNames[0].name; if (ResidentNames.Length > 1) { NE.ResidentName[] newResidentNames = new NE.ResidentName[ResidentNames.Length - 1]; Array.Copy(ResidentNames, 1, newResidentNames, 0, ResidentNames.Length - 1); ResidentNames = newResidentNames; } else { ResidentNames = null; } } } if (Header.nonresident_name_table_len > 0) { NonResidentNames = GetResidentStrings(BaseStream, 0, Header.nonresident_name_table_off); if (NonResidentNames.Length >= 1) { ModuleDescription = NonResidentNames[0].name; if (NonResidentNames.Length > 1) { NE.ResidentName[] newNonResidentNames = new NE.ResidentName[NonResidentNames.Length - 1]; Array.Copy(NonResidentNames, 1, newNonResidentNames, 0, NonResidentNames.Length - 1); NonResidentNames = newNonResidentNames; } else { NonResidentNames = null; } } } if (Header.import_module_table_off != 0 && Header.import_module_entries > 0) { BaseStream.Position = Header.import_module_table_off + BaseExecutable.Header.new_offset; ImportedNames = new string[Header.import_module_entries]; for (int i = 0; i < Header.import_module_entries; i++) { int len = BaseStream.ReadByte(); buffer = new byte[len]; BaseStream.Read(buffer, 0, len); ImportedNames[i] = Encoding.ASCII.GetString(buffer); } } if (!string.IsNullOrEmpty(ModuleName)) { strings.Add(ModuleName); } if (!string.IsNullOrEmpty(ModuleDescription)) { strings.Add(ModuleDescription); } objectTableEntries = new ObjectTableEntry[Header.obj_no]; objectPageTableEntries = new ObjectPageTableEntry[Header.module_pages_no]; BaseStream.Position = Header.obj_table_off + BaseExecutable.Header.new_offset; buffer = new byte[Marshal.SizeOf(typeof(ObjectTableEntry))]; for (int i = 0; i < Header.obj_no; i++) { BaseStream.Read(buffer, 0, buffer.Length); objectTableEntries[i] = BigEndianMarshal.ByteArrayToStructureLittleEndian <ObjectTableEntry>(buffer); } BaseStream.Position = Header.obj_page_table_off + BaseExecutable.Header.new_offset; if (Header.signature == SIGNATURE16) { buffer = new byte[Marshal.SizeOf(typeof(ObjectPageTableEntry16))]; for (int i = 0; i < Header.module_pages_no; i++) { BaseStream.Read(buffer, 0, buffer.Length); ObjectPageTableEntry16 page16 = BigEndianMarshal.ByteArrayToStructureLittleEndian <ObjectPageTableEntry16>(buffer); int pageNo = (page16.High << 8) + page16.Low; objectPageTableEntries[i] = new ObjectPageTableEntry { DataSize = (ushort)Header.page_size, Flags = (PageTableAttributes)page16.Flags, PageDataOffset = (uint)((pageNo - 1) * Header.page_size) }; } } else { buffer = new byte[Marshal.SizeOf(typeof(ObjectPageTableEntry))]; for (int i = 0; i < Header.module_pages_no; i++) { BaseStream.Read(buffer, 0, buffer.Length); objectPageTableEntries[i] = BigEndianMarshal.ByteArrayToStructureLittleEndian <ObjectPageTableEntry>(buffer); } } int debugSections = 0; int winrsrcSections = 0; if (Header.debug_info_len > 0) { debugSections = 1; } if (Header.win_res_len > 0) { winrsrcSections = 1; } Segment[] sections = new Segment[objectTableEntries.Length + debugSections + winrsrcSections]; for (int i = 0; i < objectTableEntries.Length; i++) { sections[i] = new Segment { Flags = $"{objectTableEntries[i].ObjectFlags}" }; if (objectTableEntries[i].ObjectFlags.HasFlag(ObjectFlags.Resource)) { sections[i].Name = ".rsrc"; } else if (objectTableEntries[i].ObjectFlags.HasFlag(ObjectFlags.Executable)) { sections[i].Name = ".text"; } else if (!objectTableEntries[i].ObjectFlags.HasFlag(ObjectFlags.Writable)) { sections[i].Name = ".rodata"; } else if (StringHandlers.CToString(objectTableEntries[i].Name).ToLower() == "bss") { sections[i].Name = ".bss"; } else if (!string.IsNullOrWhiteSpace(StringHandlers.CToString(objectTableEntries[i].Name).Trim())) { sections[i].Name = StringHandlers.CToString(objectTableEntries[i].Name).Trim(); } else { sections[i].Name = ".data"; } if (objectTableEntries[i].PageTableEntries == 0 || objectTableEntries[i].PageTableIndex > objectPageTableEntries.Length) { sections[i].Size = objectTableEntries[i].VirtualSize; continue; } int shift = (int)(Header.signature == SIGNATURE16 ? 0 : Header.page_off_shift); if (objectPageTableEntries[objectTableEntries[i].PageTableIndex - 1] .Flags.HasFlag(PageTableAttributes.IteratedDataPage)) { sections[i].Offset = (objectPageTableEntries[objectTableEntries[i].PageTableIndex - 1].PageDataOffset << shift) + Header.obj_iter_pages_off; } else if (objectPageTableEntries[objectTableEntries[i].PageTableIndex - 1] .Flags.HasFlag(PageTableAttributes.LegalPhysicalPage)) { sections[i].Offset = (objectPageTableEntries[objectTableEntries[i].PageTableIndex - 1].PageDataOffset << shift) + Header.data_pages_off; } else { sections[i].Offset = 0; } sections[i].Size = 0; for (int j = 0; j < objectTableEntries[i].PageTableEntries; j++) { sections[i].Size += objectPageTableEntries[j + objectTableEntries[i].PageTableIndex - 1].DataSize; } if (sections[i].Offset + sections[i].Size > BaseStream.Length) { sections[i].Size = BaseStream.Length - sections[i].Offset; } } if (winrsrcSections > 0) { sections[sections.Length - debugSections - winrsrcSections] = new Segment { Name = ".rsrc", Size = Header.win_res_len, Offset = Header.win_res_off } } ; if (debugSections > 0) { sections[sections.Length - debugSections] = new Segment { Name = ".debug", Size = Header.debug_info_len, Offset = Header.debug_info_off } } ; // It only contains a RT_VERSION resource prefixed by some 12-byte header I can't find information about, so let's just skip it. if (winrsrcSections > 0) { buffer = new byte[Header.win_res_len]; BaseStream.Position = Header.win_res_off + 12; BaseStream.Read(buffer, 0, buffer.Length); WinVersion = new NE.Version(buffer); strings.AddRange(from s in WinVersion.StringsByLanguage from k in s.Value select k.Value); } resources = new ResourceTableEntry[Header.resource_entries]; BaseStream.Position = Header.resource_table_off + BaseExecutable.Header.new_offset; buffer = new byte[Marshal.SizeOf(typeof(ResourceTableEntry))]; for (int i = 0; i < resources.Length; i++) { BaseStream.Read(buffer, 0, buffer.Length); resources[i] = BigEndianMarshal.ByteArrayToStructureLittleEndian <ResourceTableEntry>(buffer); } SortedDictionary <ResourceTypes, List <NE.Resource> > os2Resources = new SortedDictionary <ResourceTypes, List <NE.Resource> >(); for (int i = 0; i < resources.Length; i++) { os2Resources.TryGetValue(resources[i].type, out List <NE.Resource> thisResourceType); if (thisResourceType == null) { thisResourceType = new List <NE.Resource>(); } NE.Resource thisResource = new NE.Resource { id = resources[i].id, name = $"{resources[i].id}", flags = 0, dataOffset = (uint)(sections[resources[i].obj_no - 1].Offset + resources[i].offset), length = resources[i].size }; thisResource.data = new byte[thisResource.length]; BaseStream.Position = thisResource.dataOffset; BaseStream.Read(thisResource.data, 0, thisResource.data.Length); thisResourceType.Add(thisResource); os2Resources.Remove(resources[i].type); os2Resources.Add(resources[i].type, thisResourceType); } if (os2Resources.Count > 0) { neFormatResourceTable = new NE.ResourceTable(); int counter = 0; neFormatResourceTable.types = new NE.ResourceType[os2Resources.Count]; foreach (KeyValuePair <ResourceTypes, List <NE.Resource> > kvp in os2Resources) { neFormatResourceTable.types[counter].count = (ushort)kvp.Value.Count; neFormatResourceTable.types[counter].id = (ushort)kvp.Key; neFormatResourceTable.types[counter].name = Resources.IdToName((ushort)kvp.Key); neFormatResourceTable.types[counter].resources = kvp.Value.OrderBy(r => r.id).ToArray(); counter++; } foreach (NE.ResourceType rtype in neFormatResourceTable.types) { if (rtype.name != "RT_STRING") { continue; } strings.AddRange(NE.GetOs2Strings(rtype)); } } Segments = sections; Strings = strings; }
private void FillInternalBuffer(int count) { BaseStream.Read(this.buffer, 0, count); }
public int Read(byte[] buffer, int offset, int count) { if (!IsOpen) { throw new EndOfStreamException("File not open"); } while (true) { // check if we have credit and continue if (count < bytecredit) { bytecredit -= count; break; } // get the time taken since last read in seconds double LapsedSinceLastRead = (DateTime.Now - lastread).TotalSeconds; // escape if we are out of range if (LapsedSinceLastRead < 0 || LapsedSinceLastRead > 2) { break; } // get our target bps for this time slice. int targetbps = (int)(bps * LapsedSinceLastRead) + bytecredit; // check if out target+count is less than our required bps if (count < targetbps) { bytecredit = targetbps - count; break; } System.Threading.Thread.Sleep(1); } lastread = DateTime.Now; if (lastsecond != DateTime.Now.Second) { Console.WriteLine("CommsFile Read bps {0}", currentbps); currentbps = 0; lastsecond = DateTime.Now.Second; } currentbps += count; int ret = BaseStream.Read(buffer, offset, count); if (buffer[0] == 254 && offset == 1) { step = buffer[1] + 5 + 2; // + header + checksum } step -= ret; // read the timestamp //if (step == 0) //BaseStream.Read(new byte[8], 0, 8); return(ret); }
public override int Read(byte[] buffer, int offset, int count) { int read = 0; for (int i = offset; read < count; i++) { if (MaxReadPosition >= 0 && BaseStream.Position >= MaxReadPosition) { break; } if (BaseStream.Read(_singleBuf, 0, 1) <= 0) { break; } var b = _singleBuf[0]; if (_bytesAfterEqualsSign == 0) { if (b == '=') { _bytesAfterEqualsSign = 1; continue; } buffer[read++] = b; continue; } _triBuf[_bytesAfterEqualsSign] = b; _bytesAfterEqualsSign++; if (_bytesAfterEqualsSign < 3) { continue; } _bytesAfterEqualsSign = 0; if (_triBuf[1] == '\r' || _triBuf[1] == '\n') { if (!IgnoreErrors && _triBuf[2] != '\r' && _triBuf[2] != '\n') { throw new InvalidOperationException("Cannot decode sequence =" + Escape(_triBuf[1]) + Escape(_triBuf[2])); } continue; } int val1 = _triBuf[1]; val1 -= (val1 < 58 ? 48 : (val1 < 97 ? 55 : 87)); int val2 = _triBuf[2]; val2 -= (val2 < 58 ? 48 : (val2 < 97 ? 55 : 87)); if (val1 < 0 || val1 > 15) { if (!IgnoreErrors) { throw new InvalidOperationException("Cannot decode sequence =" + Escape(_triBuf[1]) + Escape(_triBuf[2])); } val1 = 0; val2 = 0; } if (val2 < 0 || val2 > 15) { if (!IgnoreErrors) { throw new InvalidOperationException("Cannot decode sequence =" + Escape(_triBuf[1]) + Escape(_triBuf[2])); } val1 = 0; val2 = 0; } buffer[read++] = ((byte)((val1 << 4) | val2)); } return(read); }
/// <summary> /// Read a string while checking the string precursor for intern opportunities. /// Taken from ndp\clr\src\bcl\system\io\binaryreader.cs-ReadString() /// </summary> override public String ReadString() { char[] resultBuffer = null; try { MemoryStream memoryStream = this.BaseStream as MemoryStream; int currPos = 0; int n = 0; int stringLength; int readLength; int charsRead = 0; // Length of the string in bytes, not chars stringLength = Read7BitEncodedInt(); if (stringLength < 0) { throw new IOException(); } if (stringLength == 0) { return(String.Empty); } char[] charBuffer = _buffer.CharBuffer; do { readLength = ((stringLength - currPos) > MaxCharsBuffer) ? MaxCharsBuffer : (stringLength - currPos); byte[] rawBuffer = null; int rawPosition = 0; if (memoryStream != null) { // Optimization: we can avoid reading into a byte buffer // and instead read directly from the memorystream's backing buffer rawBuffer = memoryStream.GetBuffer(); rawPosition = (int)memoryStream.Position; int length = (int)memoryStream.Length; n = (rawPosition + readLength) < length ? readLength : length - rawPosition; // Attempt to track down an intermittent failure -- n should not ever be negative, but // we're occasionally seeing it when we do the decoder.GetChars below -- by providing // a bit more information when we do hit the error, in the place where (by code inspection) // the actual error seems most likely to be occurring. if (n < 0) { ErrorUtilities.ThrowInternalError("From calculating based on the memorystream, about to read n = {0}. length = {1}, rawPosition = {2}, readLength = {3}, stringLength = {4}, currPos = {5}.", n, length, rawPosition, readLength, stringLength, currPos); } memoryStream.Seek(n, SeekOrigin.Current); } if (rawBuffer == null) { rawBuffer = _buffer.ByteBuffer; rawPosition = 0; n = BaseStream.Read(rawBuffer, 0, readLength); // See above explanation -- the OutOfRange exception may also be coming from our setting of n here ... if (n < 0) { ErrorUtilities.ThrowInternalError("From getting the length out of BaseStream.Read directly, about to read n = {0}. readLength = {1}, stringLength = {2}, currPos = {3}", n, readLength, stringLength, currPos); } } if (n == 0) { throw new EndOfStreamException(); } if (currPos == 0 && n == stringLength) { charsRead = _decoder.GetChars(rawBuffer, rawPosition, n, charBuffer, 0); return(Strings.WeakIntern(charBuffer.AsSpan(0, charsRead))); } #if !CLR2COMPATIBILITY resultBuffer ??= ArrayPool <char> .Shared.Rent(stringLength); // Actual string length in chars may be smaller. #else // Since NET35 is only used in rare TaskHost processes, we decided to leave it as-is. resultBuffer ??= new char[stringLength]; // Actual string length in chars may be smaller. #endif charsRead += _decoder.GetChars(rawBuffer, rawPosition, n, resultBuffer, charsRead); currPos += n; }while (currPos < stringLength); var retval = Strings.WeakIntern(resultBuffer.AsSpan(0, charsRead)); return(retval); } catch (Exception e) { Debug.Assert(false, e.ToString()); throw; } #if !CLR2COMPATIBILITY finally { // resultBuffer shall always be either Rented or null if (resultBuffer != null) { ArrayPool <char> .Shared.Return(resultBuffer); } } #endif }
/// <summary> /// Reads a <see cref="Double"/> from the <see cref="BaseStream"/>. /// </summary> /// <returns>The <see cref="Double"/> value.</returns> public Double ReadDouble() { byte[] buffer = new byte[sizeof(Double)]; BaseStream.Read(buffer, 0, buffer.Length); return(Binary.ReadDouble(buffer, 0, ReadsLittleEndian)); }
/// <summary> /// Reads a single byte and determines whether it /// represents a true value or a false value. /// </summary> /// <returns>True if the byte is non-zero, otherwise false.</returns> public bool ReadBoolean() { byte[] buffer = new byte[1]; BaseStream.Read(buffer, 0, buffer.Length); return(buffer[0] != 0x00); }
public override int Read(byte[] buffer, int offset, int count) => BaseStream.Read(buffer, offset, count);
/// <summary> /// Reads an <see cref="Int64"/> from the <see cref="BaseStream"/>. /// </summary> /// <returns>The <see cref="Int64"/> value.</returns> public Int64 ReadInt64() { byte[] buffer = new byte[sizeof(Int64)]; BaseStream.Read(buffer, 0, buffer.Length); return(Binary.ReadInt64(buffer, 0, ReadsLittleEndian)); }
/// <summary> /// Move to the next segment line in the stream /// </summary> /// <param name="delims">Delimiters so the line can be split correctlys</param> /// <returns>A BaseFieldValues object that can be ingested by a derived segment type in a hard coded document format</returns> public BaseFieldValues ReadNextLine(Delimiters delims) { var index = _tail; var exitbyte = (byte)delims.Segment; var sb = new MemoryStream(); if (_head == 0 || _tail == BufferSize || _tail == _head) { _head = BaseStream.Read(_buffer, (int)0, (int)(BufferSize)); _tail = 0; index = 0; if (_head == 0) { EndOfFile = true; return(null); } } while (_buffer[index] != exitbyte) { index++; if (index >= BufferSize || index >= _head) { if (BaseStream.Position == BaseStream.Length) { EndOfFile = true; return(null); } if ((_buffer[_tail] == 10) || (_buffer[_tail] == 13)) { _tail++;//since some incorrectly set line ending to \r\n } sb.Write(_buffer, (int)_tail, (int)(BufferSize - _tail)); _head = BaseStream.Read(_buffer, (int)0, (int)(BufferSize)); index = 0; _tail = 0; } } var oldtail = _tail; _tail = index + 1; if (index >= _head && BaseStream.Position == BaseStream.Length) { EndOfFile = true; } if (sb.Length == 0) { if ((_buffer[oldtail] == 10 && _buffer[oldtail + 1] == 13) || (_buffer[oldtail] == 13 && _buffer[oldtail + 1] == 10)) { oldtail++;//since some incorrectly set line ending to \r\n and yet someone also did \n\r } if ((int)(index - oldtail) == 0) { return(null); } return(new BaseFieldValues(_buffer, (int)oldtail, (int)(index - oldtail), (byte)delims.Element, delims.Component.ToString())); } else { sb.Write(_buffer, 0, (int)(index)); return(new BaseFieldValues(sb.ToArray(), (int)oldtail, (int)(sb.Length - oldtail), (byte)delims.Element, delims.Component.ToString())); } }
public unsafe int Read(Span <byte> span) #endif { if (_mode != Mode.Decompress) { throw new NotSupportedException("Read() not supported on compression"); } // Reached end of stream if (_decompSrcIdx == DecompressComplete) { return(0); } int readSize = 0; int destSize = span.Length; int destLeftBytes = span.Length; if (_firstRead) { // Write FrameMagicNumber into LZ4F_decompress UIntPtr headerSizeVal = (UIntPtr)4; UIntPtr destSizeVal = (UIntPtr)destSize; UIntPtr ret; fixed(byte *header = FrameMagicNumber) fixed(byte *dest = span) { ret = LZ4Init.Lib.FrameDecompress(_dctx, dest, ref destSizeVal, header, ref headerSizeVal, null); } LZ4FrameException.CheckReturnValue(ret); Debug.Assert(headerSizeVal.ToUInt64() <= int.MaxValue); Debug.Assert(destSizeVal.ToUInt64() <= int.MaxValue); if (headerSizeVal.ToUInt32() != 4u) { throw new InvalidOperationException("Not enough dest buffer"); } int destWritten = (int)destSizeVal.ToUInt32(); span = span.Slice(destWritten); TotalOut += destWritten; _firstRead = false; } while (0 < destLeftBytes) { if (_decompSrcIdx == _decompSrcCount) { // Read from _baseStream _decompSrcIdx = 0; _decompSrcCount = BaseStream.Read(_workBuf, 0, _workBuf.Length); TotalIn += _decompSrcCount; // _baseStream reached its end if (_decompSrcCount == 0) { _decompSrcIdx = DecompressComplete; break; } } UIntPtr srcSizeVal = (UIntPtr)(_decompSrcCount - _decompSrcIdx); UIntPtr destSizeVal = (UIntPtr)(destLeftBytes); UIntPtr ret; fixed(byte *src = _workBuf.AsSpan(_decompSrcIdx)) fixed(byte *dest = span) { ret = LZ4Init.Lib.FrameDecompress(_dctx, dest, ref destSizeVal, src, ref srcSizeVal, null); } LZ4FrameException.CheckReturnValue(ret); // The number of bytes consumed from srcBuffer will be written into *srcSizePtr (necessarily <= original value). Debug.Assert(srcSizeVal.ToUInt64() <= int.MaxValue); int srcConsumed = (int)srcSizeVal.ToUInt32(); _decompSrcIdx += srcConsumed; Debug.Assert(_decompSrcIdx <= _decompSrcCount); // The number of bytes decompressed into dstBuffer will be written into *dstSizePtr (necessarily <= original value). Debug.Assert(destSizeVal.ToUInt64() <= int.MaxValue); int destWritten = (int)destSizeVal.ToUInt32(); span = span.Slice(destWritten); destLeftBytes -= destWritten; TotalOut += destWritten; readSize += destWritten; } return(readSize); }
public void DecodeStream() { // Reset position to use same buffer zlibMemoryStream.Position = 0; // Get compressed stream length to read var buff = new byte[4]; if (BaseStream.Read(buff, 0, 4) != 4) { throw new Exception("ZRLE decoder: Invalid compressed stream size"); } // BigEndian to LittleEndian conversion var compressedBufferSize = buff[3] | (buff[2] << 8) | (buff[1] << 16) | (buff[0] << 24); if (compressedBufferSize > 64 * 1024 * 1024) { throw new Exception("ZRLE decoder: Invalid compressed data size"); } #region Decode stream // Decode stream // int pos = 0; // while (pos++ < compressedBufferSize) // zlibDecompressedStream.WriteByte(this.BaseStream.ReadByte()); #endregion #region Decode stream in blocks // Decode stream in blocks var bytesNeeded = compressedBufferSize; const int maxBufferSize = 64 * 1024; // 64k buffer var receiveBuffer = new byte[maxBufferSize]; var netStream = (NetworkStream)BaseStream; netStream.ReadTimeout = 15000; // Set timeout to 15s do { if (netStream.DataAvailable) { var bytesToRead = bytesNeeded; // the byteToRead should never exceed the maxBufferSize if (bytesToRead > maxBufferSize) { bytesToRead = maxBufferSize; } // try reading bytes (read in 1024 byte chunks) - improvement for slow connections var toRead = bytesToRead > 1024 ? 1024 : bytesToRead; var bytesRead = 0; try { bytesRead = netStream.Read(receiveBuffer, bytesRead, toRead); } catch { } // lower the bytesNeeded with the bytesRead. bytesNeeded -= bytesRead; // write the readed bytes to the decompression stream. zlibDecompressedStream.Write(receiveBuffer, 0, bytesRead); } else // there isn't any data atm. let's give the processor some time. { Thread.Sleep(100); // increased to 100ms for slow connections } } while (bytesNeeded > 0); #endregion zlibMemoryStream.Position = 0; }
public override int Read(byte[] _Buffer, int _Offset, int _Count) { return(BaseStream.Read(_Buffer, 0, _Count)); }
/// <summary> /// Reads an <see cref="UInt16"/> from the <see cref="BaseStream"/>. /// </summary> /// <returns>The <see cref="UInt16"/> value.</returns> public UInt16 ReadUInt16() { byte[] buffer = new byte[sizeof(Int16)]; BaseStream.Read(buffer, 0, buffer.Length); return(Binary.ReadUInt16(buffer, 0, ReadsLittleEndian)); }
public unsafe int Read(Span <byte> span) #endif { // For Decompress if (_mode != Mode.Decompress) { throw new NotSupportedException("Read() not supported on compression"); } if (_workBufPos == ReadDone) { return(0); } int readSize = 0; LzmaAction action = LzmaAction.Run; fixed(byte *readPtr = _workBuf) fixed(byte *writePtr = span) { _lzmaStream.NextIn = readPtr + _workBufPos; _lzmaStream.NextOut = writePtr; _lzmaStream.AvailOut = (uint)span.Length; while (_lzmaStream.AvailOut != 0) { if (_lzmaStream.AvailIn == 0) { // Read from _baseStream int baseReadSize = BaseStream.Read(_workBuf, 0, _workBuf.Length); TotalIn += baseReadSize; _workBufPos = 0; _lzmaStream.NextIn = readPtr; _lzmaStream.AvailIn = (uint)baseReadSize; if (baseReadSize == 0) // End of stream { action = LzmaAction.Finish; } } ulong bakAvailIn = _lzmaStream.AvailIn; ulong bakAvailOut = _lzmaStream.AvailOut; LzmaRet ret = XZInit.Lib.LzmaCode(_lzmaStream, action); _workBufPos += (int)(bakAvailIn - _lzmaStream.AvailIn); readSize += (int)(bakAvailOut - _lzmaStream.AvailOut); // Once everything has been decoded successfully, the return value of lzma_code() will be LZMA_STREAM_END. if (ret == LzmaRet.StreamEnd) { _workBufPos = ReadDone; break; } // Normally the return value of lzma_code() will be LZMA_OK until everything has been encoded. XZException.CheckReturnValue(ret); } } TotalOut += readSize; return(readSize); }
/// <summary> /// Reads bytes from the current position in the virtual stream. /// The number of bytes to read is determined by the length of the array. /// </summary> /// <param name="buffer">Array which will contain the read bytes after successful execution.</param> /// <returns>The total number of bytes read into the buffer. /// This might be less than the length of the array if that number /// of bytes are not currently available, or zero if the end of the stream is reached.</returns> public int Read(byte[] buffer) { return(BaseStream.Read(buffer, 0, buffer.Length)); }
/// <summary> /// Read a string while checking the string precursor for intern opportunities. /// Taken from ndp\clr\src\bcl\system\io\binaryreader.cs-ReadString() /// </summary> override public String ReadString() { try { MemoryStream memoryStream = this.BaseStream as MemoryStream; int currPos = 0; int n = 0; int stringLength; int readLength; int charsRead; // Length of the string in bytes, not chars stringLength = Read7BitEncodedInt(); if (stringLength < 0) { throw new IOException(); } if (stringLength == 0) { return(String.Empty); } char[] charBuffer = _buffer.CharBuffer; StringBuilder sb = null; do { readLength = ((stringLength - currPos) > MaxCharsBuffer) ? MaxCharsBuffer : (stringLength - currPos); byte[] rawBuffer = null; int rawPosition = 0; if (memoryStream != null) { // Optimization: we can avoid reading into a byte buffer // and instead read directly from the memorystream's backing buffer #if FEATURE_MEMORYSTREAM_GETBUFFER rawBuffer = memoryStream.GetBuffer(); rawPosition = (int)memoryStream.Position; int length = (int)memoryStream.Length; n = (rawPosition + readLength) < length ? readLength : length - rawPosition; // Attempt to track down an intermittent failure -- n should not ever be negative, but // we're occasionally seeing it when we do the decoder.GetChars below -- by providing // a bit more information when we do hit the error, in the place where (by code inspection) // the actual error seems most likely to be occurring. if (n < 0) { ErrorUtilities.ThrowInternalError("From calculating based on the memorystream, about to read n = {0}. length = {1}, rawPosition = {2}, readLength = {3}, stringLength = {4}, currPos = {5}.", n, length, rawPosition, readLength, stringLength, currPos); } #else ArraySegment <byte> rawBufferSegment; if (memoryStream.TryGetBuffer(out rawBufferSegment)) { rawBuffer = rawBufferSegment.Array; rawPosition = rawBufferSegment.Offset + (int)memoryStream.Position; long maxReadLength = memoryStream.Length - memoryStream.Position; n = readLength > maxReadLength ? (int)maxReadLength : readLength; } #endif } if (rawBuffer == null) { rawBuffer = _buffer.ByteBuffer; rawPosition = 0; n = BaseStream.Read(rawBuffer, 0, readLength); // See above explanation -- the OutOfRange exception may also be coming from our setting of n here ... if (n < 0) { ErrorUtilities.ThrowInternalError("From getting the length out of BaseStream.Read directly, about to read n = {0}. readLength = {1}, stringLength = {2}, currPos = {3}", n, readLength, stringLength, currPos); } } if (n == 0) { throw new EndOfStreamException(); } charsRead = _decoder.GetChars(rawBuffer, rawPosition, n, charBuffer, 0); if (memoryStream != null) { memoryStream.Seek(readLength, SeekOrigin.Current); } if (currPos == 0 && n == stringLength) { return(OpportunisticIntern.CharArrayToString(charBuffer, charsRead)); } if (sb == null) { sb = new StringBuilder(stringLength); // Actual string length in chars may be smaller. } sb.Append(charBuffer, 0, charsRead); currPos += n; }while (currPos < stringLength); return(OpportunisticIntern.StringBuilderToString(sb)); } catch (Exception e) { Debug.Assert(false, e.ToString()); throw; } }
/// <summary> /// Reads bytes from the current position in the virtual stream. /// </summary> /// <param name="buffer">Array which will contain the read bytes after successful execution.</param> /// <param name="count">Number of bytes to read.</param> /// <returns>The total number of bytes read into the buffer. /// This might be less than the number of bytes requested if that number /// of bytes are not currently available, or zero if the end of the stream is reached.</returns> public int Read(byte[] buffer, int count) { return(BaseStream.Read(buffer, 0, count)); }
/// <summary> /// Return the bytes requested from the container /// </summary> public override int Read(byte[] buffer, int offset, int count) { // throw if version missing ReadAttempt(true); return(BaseStream.Read(buffer, offset, count)); }
/* ----------------------------------------------------------------- */ /// /// Read /// /// <summary> /// データを読み込みます。 /// </summary> /// /// <param name="buffer">バッファ</param> /// <param name="size">読み込むサイズ</param> /// /// <returns>実際に読み込まれたサイズ</returns> /// /* ----------------------------------------------------------------- */ public int Read(byte[] buffer, uint size) => BaseStream.Read(buffer, 0, (int)size);
void Initialize() { Recognized = false; if (BaseStream == null) { return; } BaseStream.Seek(0, SeekOrigin.Begin); byte[] buffer = new byte[Marshal.SizeOf(typeof(GeodeHeaderV2))]; BaseStream.Read(buffer, 0, buffer.Length); header = BigEndianMarshal.ByteArrayToStructureLittleEndian <GeodeHeader>(buffer); header2 = BigEndianMarshal.ByteArrayToStructureLittleEndian <GeodeHeaderV2>(buffer); Recognized = header.magic == GEOS_ID && header.type == FileType.GFT_EXECUTABLE || header2.magic == GEOS2_ID && header2.type == FileType2.GFT_EXECUTABLE; if (!Recognized) { return; } isNewHeader = header2.magic == GEOS2_ID; RequiredOperatingSystem = new OperatingSystem { Name = "GEOS", MajorVersion = isNewHeader ? 2 : 1 }; List <string> strings = new List <string> { StringHandlers.CToString(isNewHeader ? header2.name : header.name, geosEncoding), StringHandlers.CToString(isNewHeader ? header2.copyright : header.copyright, geosEncoding), StringHandlers.CToString(isNewHeader ? header2.info : header.info, geosEncoding) }; uint segmentBase = 0; if (isNewHeader) { BaseStream.Position = Marshal.SizeOf(typeof(GeodeHeaderV2)); buffer = new byte[Marshal.SizeOf(typeof(ApplicationHeaderV2))]; segmentBase = (uint)Marshal.SizeOf(typeof(GeodeHeaderV2)); BaseStream.Read(buffer, 0, buffer.Length); applicationHeader2 = BigEndianMarshal.ByteArrayToStructureLittleEndian <ApplicationHeaderV2>(buffer); imports = new Import[applicationHeader2.imports]; exports = new Export[applicationHeader2.exports]; segments = new SegmentDescriptor[applicationHeader2.segments]; strings.Add($"{StringHandlers.CToString(applicationHeader2.name, geosEncoding).Trim()}.{StringHandlers.CToString(applicationHeader2.extension, geosEncoding).Trim()}"); } else { BaseStream.Position = Marshal.SizeOf(typeof(GeodeHeader)); buffer = new byte[Marshal.SizeOf(typeof(ApplicationHeader))]; BaseStream.Read(buffer, 0, buffer.Length); applicationHeader = BigEndianMarshal.ByteArrayToStructureLittleEndian <ApplicationHeader>(buffer); imports = new Import[applicationHeader.imports]; exports = new Export[applicationHeader.exports]; segments = new SegmentDescriptor[applicationHeader.segments]; strings.Add($"{StringHandlers.CToString(applicationHeader.name, geosEncoding).Trim()}.{StringHandlers.CToString(applicationHeader.extension, geosEncoding).Trim()}"); } buffer = new byte[Marshal.SizeOf(typeof(Import))]; for (int i = 0; i < imports.Length; i++) { BaseStream.Read(buffer, 0, buffer.Length); imports[i] = BigEndianMarshal.ByteArrayToStructureLittleEndian <Import>(buffer); strings.Add(StringHandlers.CToString(imports[i].name, geosEncoding).Trim()); } buffer = new byte[Marshal.SizeOf(typeof(Export))]; for (int i = 0; i < exports.Length; i++) { BaseStream.Read(buffer, 0, buffer.Length); exports[i] = BigEndianMarshal.ByteArrayToStructureLittleEndian <Export>(buffer); } if (segments.Length > 0) { buffer = new byte[Marshal.SizeOf(typeof(SegmentDescriptor)) * segments.Length]; BaseStream.Read(buffer, 0, buffer.Length); Segment[] mySegments = new Segment[segments.Length]; for (int i = 0; i < segments.Length; i++) { segments[i].length = BitConverter.ToUInt16(buffer, 2 * i); segments[i].offset = BitConverter.ToUInt32(buffer, 2 * segments.Length + 4 * i) + segmentBase; segments[i].relocs_length = BitConverter.ToUInt16(buffer, 6 * segments.Length + 2 * i); segments[i].flags = (SegmentFlags)BitConverter.ToUInt16(buffer, 8 * segments.Length + 2 * i); mySegments[i] = new Segment { Flags = $"{segments[i].flags}", Offset = segments[i].offset, Size = segments[i].length }; if (i == 1) { mySegments[i].Name = ".idata"; } else if (segments[i].flags.HasFlag(SegmentFlags.HAF_CODE)) { mySegments[i].Name = ".text"; } else if (segments[i].flags.HasFlag(SegmentFlags.HAF_OBJECT_RESOURCE)) { mySegments[i].Name = ".rsrc"; } else if (segments[i].flags.HasFlag(SegmentFlags.HAF_ZERO_INIT)) { mySegments[i].Name = ".bss"; } else if (segments[i].flags.HasFlag(SegmentFlags.HAF_READ_ONLY)) { mySegments[i].Name = ".rodata"; } else { mySegments[i].Name = ".data"; } } Segments = mySegments; } strings.Remove(""); strings.Remove(null); Strings = strings; }
public int ReadBlock(byte[] buffer, int offset, int size) { return(BaseStream.Read(buffer, offset, size)); }
public string ReadString(StringStyle Style, FieldInfo Info = null) { List <byte> Buffer = new List <byte>(); switch (Style) { case StringStyle.CString: while (true) { byte Byte = base.ReadByte(); if (Byte < 1) { break; } Buffer.Add(Byte); } return(Encoding.GetString(Buffer.ToArray())); case StringStyle.UCString: while (true) { byte Byte1 = base.ReadByte(); byte Byte2 = base.ReadByte(); if (Byte1 == 0x00 && Byte2 == 0x00) { break; } Buffer.Add(Byte1); Buffer.Add(Byte2); } return(Encoding.GetString(Buffer.ToArray())); case StringStyle.PString: if (Info != null) { long Len; string Prefix = Tools.GetAttributePropertyValue(Info, Const.PSTRING, "PrefixType"); bool UnicodeLength = Tools.GetAttributePropertyValue(Info, Const.PSTRING, "UnicodeLength"); switch (Prefix) { case Const.INT16: if (BigEndian) { Len = Tools.Reverse(ReadInt16()); } else { Len = ReadInt16(); } break; case Const.UINT16: if (BigEndian) { Len = Tools.Reverse(ReadUInt16()); } else { Len = ReadUInt16(); } break; case Const.UINT8: if (BigEndian) { Len = Tools.Reverse(ReadByte()); } else { Len = ReadByte(); } break; case Const.INT8: if (BigEndian) { Len = Tools.Reverse(ReadSByte()); } else { Len = ReadSByte(); } break; case Const.INT32: if (BigEndian) { Len = Tools.Reverse(ReadInt32()); } else { Len = ReadInt32(); } break; case Const.UINT32: if (BigEndian) { Len = Tools.Reverse(ReadUInt32()); } else { Len = ReadUInt32(); } break; case Const.INT64: if (BigEndian) { Len = Tools.Reverse(ReadInt64()); } else { Len = ReadInt64(); } break; default: throw new Exception("Invalid Data Type"); } if (UnicodeLength) { Len *= 2; } if (Len > BaseStream.Length - BaseStream.Position) { throw new Exception("Invalid Length"); } byte[] Buff = new byte[Len]; while (Len > 0) { Len -= BaseStream.Read(Buff, 0, Len > int.MaxValue ? int.MaxValue : (int)Len); } return(Encoding.GetString(Buff)); } else { return(ReadString()); } default: throw new Exception("Unk Value Type"); } }
private byte[] ReadData(int length) { byte[] data = new byte[length]; BaseStream.Read(data, 0, length); return(data); }
public override int Read(byte[] buffer, int offset, int count) { var bytes = new List <byte>(); while (currentChunkSize == 0) { var b = BaseStream.ReadByte(); if (b < 0) { return(0); } if (b == '\r') { b = BaseStream.ReadByte(); if (b < 0) { return(0); } if (b == '\n') { var line = System.Text.Encoding.ASCII.GetString(bytes.ToArray()); bytes.Clear(); if (line != "") { int len; if (Int32.TryParse( line.Split(';')[0], System.Globalization.NumberStyles.AllowHexSpecifier, System.Globalization.CultureInfo.InvariantCulture.NumberFormat, out len)) { if (len == 0) { return(0); } else { currentChunkSize = len; } } else { throw new HTTPError(HttpStatusCode.BadRequest); } } } else { bytes.Add((byte)'\r'); bytes.Add((byte)b); } } else { bytes.Add((byte)b); } } if (currentChunkSize > 0) { int len = BaseStream.Read(buffer, offset, Math.Min(count, currentChunkSize)); if (len >= 0) { offset += len; count -= len; currentChunkSize -= len; } if (currentChunkSize == 0) { BaseStream.ReadByte(); //\r BaseStream.ReadByte(); //\n } return(len); } else { return(0); } }
public override int read(sbyte [] b, int off, int len) { int r = BaseStream.Read((byte [])TypeUtils.ToByteArray(b), off, len); return(r == 0 ? -1 : r); }
/// <summary> /// Reads a sequence of bytes from the underlying stream and advances the position within the stream by the number of bytes read. /// </summary> /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array /// with the values between offset and (offset + count - 1) replaced by the bytes read from the underlying source.</param> /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the underlying stream.</param> /// <param name="count">The maximum number of bytes to be read from the underlying stream. </param> /// <returns>The total number of bytes read into the buffer. This can be less than the number of bytes requested if that /// many bytes are not currently available, or zero (0) if the end of the underlying stream has been reached.</returns> public override int Read(byte[] buffer, int offset, int count) { return(BaseStream.Read(buffer, offset, count)); }
public virtual int Read(byte[] buffer, int offset, int count) { return(BaseStream.Read(buffer, offset, count)); }