internal InitialHandshakePacket(ByteArrayReader reader) { reader.ReadByte(c_protocolVersion); ServerVersion = reader.ReadNullTerminatedByteString(); var connectionId = reader.ReadInt32(); AuthPluginData = reader.ReadByteString(8); reader.ReadByte(0); var capabilityFlagsLow = reader.ReadUInt16(); if (reader.BytesRemaining > 0) { var charSet = (CharacterSet) reader.ReadByte(); ServerStatus status = (ServerStatus) reader.ReadInt16(); var capabilityFlagsHigh = reader.ReadUInt16(); ProtocolCapabilities = (ProtocolCapabilities) (capabilityFlagsHigh << 16 | capabilityFlagsLow); var authPluginDataLength = reader.ReadByte(); var unused = reader.ReadByteString(10); if (ProtocolCapabilities.HasFlag(ProtocolCapabilities.SecureConnection) && authPluginDataLength > 0) { var authPluginData2 = reader.ReadByteString(Math.Max(13, authPluginDataLength - 8)); var concatenated = new byte[AuthPluginData.Length + authPluginData2.Length]; Buffer.BlockCopy(AuthPluginData, 0, concatenated, 0, AuthPluginData.Length); Buffer.BlockCopy(authPluginData2, 0, concatenated, AuthPluginData.Length, authPluginData2.Length); AuthPluginData = concatenated; } if (ProtocolCapabilities.HasFlag(ProtocolCapabilities.PluginAuth)) AuthPluginName = Encoding.UTF8.GetString(reader.ReadNullTerminatedByteString()); } }
CommResponse IProtocolCodec.ClientDecode(CommDataBase data) { var client = (ModbusClient)data.OwnerProtocol; var command = (ModbusCommand)data.UserData; var incoming = data.IncomingData; var bodyLen = incoming.Length - 4; //validate address first if (bodyLen >= 0 && incoming.ReadByte() == client.Address) { //extract function code var fncode = incoming.ReadByte(); //extract the message body var body = new ByteArrayReader(incoming.ReadBytes(bodyLen)); //calculate the CRC-16 over the received stream ushort crc = ByteArrayHelpers.CalcCRC16( incoming.ToArray(), 0, incoming.Length - 2); //validate the CRC-16 short u = incoming.ReadInt16LE(); if (u == (short)crc) { //message looks consistent (although the body can be empty) if ((fncode & 0x7F) == command.FunctionCode) { if (fncode <= 0x7F) { // //encode the command body, if applies var codec = CommandCodecs[fncode]; if (codec != null) codec.ClientDecode(command, body); return new CommResponse( data, CommResponse.Ack); } else { //exception if (incoming.CanRead(1)) command.ExceptionCode = incoming.ReadByte(); return new CommResponse( data, CommResponse.Critical); } } } } return new CommResponse( data, CommResponse.Unknown); }
public static ColumnDefinitionPayload Create(PayloadData payload) { var reader = new ByteArrayReader(payload.ArraySegment); var catalog = reader.ReadLengthEncodedByteString(); var schema = reader.ReadLengthEncodedByteString(); var table = reader.ReadLengthEncodedByteString(); var physicalTable = reader.ReadLengthEncodedByteString(); var name = Encoding.UTF8.GetString(reader.ReadLengthEncodedByteString()); var physicalName = reader.ReadLengthEncodedByteString(); reader.ReadByte(0x0C); // length of fixed-length fields, always 0x0C var characterSet = (CharacterSet) reader.ReadUInt16(); var columnLength = (int) reader.ReadUInt32(); var columnType = (ColumnType) reader.ReadByte(); var columnFlags = (ColumnFlags) reader.ReadUInt16(); var decimals = reader.ReadByte(); // 0x00 for integers and static strings, 0x1f for dynamic strings, double, float, 0x00 to 0x51 for decimals reader.ReadByte(0); if (reader.BytesRemaining > 0) { int defaultValuesCount = checked((int) reader.ReadLengthEncodedInteger()); for (int i = 0; i < defaultValuesCount; i++) reader.ReadLengthEncodedByteString(); } if (reader.BytesRemaining != 0) throw new FormatException("Extra bytes at end of payload."); return new ColumnDefinitionPayload(name, characterSet, columnLength, columnType, columnFlags); }
protected override int ReadFromByteArray(ByteArrayReader reader) { base.ReadFromByteArray(reader); CardIndex = reader.ReadInt32(); Card = reader.Read<Card>(); return reader.Index; }
/// <summary> /// Extract the typical header for a request command (server-side) /// </summary> /// <param name="command"></param> /// <param name="body"></param> internal static void PopRequestHeader( ModbusCommand command, ByteArrayReader body) { command.Offset = body.ReadUInt16BE(); command.Count = body.ReadInt16BE(); }
protected override int ReadFromByteArray(ByteArrayReader reader) { base.ReadFromByteArray(reader); Success = reader.ReadBool(); Message = reader.ReadString(); return reader.Index; }
public override void ClientDecode( ModbusCommand command, ByteArrayReader body) { ModbusCodecBase.PopDiscretes( command, body); }
public override void ClientDecode( ModbusCommand command, ByteArrayReader body) { ModbusCodecBase.PopRequestHeader( command, body); }
public static AuthenticationMethodSwitchRequestPayload Create(PayloadData payload) { var reader = new ByteArrayReader(payload.ArraySegment); reader.ReadByte(Signature); var name = Encoding.UTF8.GetString(reader.ReadNullTerminatedByteString()); var data = reader.ReadByteString(reader.BytesRemaining); return new AuthenticationMethodSwitchRequestPayload(name, data); }
public override void ClientDecode( ModbusCommand command, ByteArrayReader body) { var count = body.ReadByte() / 2; command.Data = new ushort[count]; for (int i = 0; i < count; i++) command.Data[i] = body.ReadUInt16BE(); }
public Packet BuildFrom(byte[] bytes) { var reader = new ByteArrayReader(bytes, 0); var typeInt = reader.ReadInt32(); var name = NameFromType(typeInt); var packet = _packetCache[name].Copy(); packet.FromByteArray(bytes, 0); return packet; }
public override void ServerDecode( ModbusCommand command, ByteArrayReader body) { ModbusCodecBase.PopRequestHeader( command, body); command.Data = new ushort[command.Count]; command.QueryTotalLength += 2; }
public override void ServerDecode( ModbusCommand command, ByteArrayReader body) { command.Offset = body.ReadUInt16BE(); command.Count = 1; command.QueryTotalLength += 2; command.Data = new ushort[1]; command.Data[0] = body.ReadUInt16BE(); }
public static ErrorPayload Create(PayloadData payload) { var reader = new ByteArrayReader(payload.ArraySegment); reader.ReadByte(Signature); var errorCode = reader.ReadUInt16(); reader.ReadByte(0x23); var state = Encoding.ASCII.GetString(reader.ReadByteString(5)); var message = Encoding.UTF8.GetString(reader.ReadByteString(payload.ArraySegment.Count - 9)); return new ErrorPayload(errorCode, state, message); }
public static OkPayload Create(PayloadData payload) { var reader = new ByteArrayReader(payload.ArraySegment); reader.ReadByte(Signature); var affectedRowCount = checked((int) reader.ReadLengthEncodedInteger()); var lastInsertId = checked((long) reader.ReadLengthEncodedInteger()); var serverStatus = (ServerStatus) reader.ReadUInt16(); var warningCount = (int) reader.ReadUInt16(); return new OkPayload(affectedRowCount, lastInsertId, serverStatus, warningCount); }
public override void ServerDecode( ModbusCommand command, ByteArrayReader body) { ModbusCodecBase.PopRequestHeader( command, body); ModbusCodecBase.PopDiscretes( command, body); }
public static EofPayload Create(PayloadData payload) { var reader = new ByteArrayReader(payload.ArraySegment); reader.ReadByte(Signature); if (payload.ArraySegment.Count > 5) throw new FormatException("Not an EOF packet"); int warningCount = reader.ReadUInt16(); ServerStatus serverStatus = (ServerStatus) reader.ReadUInt16(); if (reader.BytesRemaining != 0) throw new FormatException("Extra bytes at end of payload."); return new EofPayload(warningCount, serverStatus); }
public static PrepareStatementOkPayload Create(PayloadData payload) { var reader = new ByteArrayReader(payload.ArraySegment); reader.ReadByte(0); var statementId = reader.ReadUInt32(); int columnCount = reader.ReadUInt16(); int parameterCount = reader.ReadUInt16(); reader.ReadByte(0); int warningCount = reader.ReadUInt16(); if (reader.BytesRemaining != 0) throw new FormatException("Extra bytes at end of payload."); return new PrepareStatementOkPayload(statementId, columnCount, parameterCount, warningCount); }
public override void ServerDecode( ModbusCommand command, ByteArrayReader body) { ModbusCodecBase.PopRequestHeader( command, body); var count = body.ReadByte() / 2; command.Data = new ushort[count]; command.QueryTotalLength += (count + 3); for (int i = 0; i < count; i++) command.Data[i] = body.ReadUInt16BE(); }
protected override int ReadFromByteArray(ByteArrayReader reader) { base.ReadFromByteArray(reader); IsGameStarted = reader.ReadBool(); DeckSize = reader.ReadInt32(); PlayerIndex = reader.ReadInt32(); Reverse = reader.ReadBool(); Top = reader.Read<Card>(); Winner = reader.ReadString(); Players = reader.ReadStringList(); PlayerHandSizes = reader.ReadIntList(); Cards = reader.ReadList<Card>(); return reader.Index; }
private static long ReadFieldLength(ByteArrayReader reader) { var leadByte = reader.ReadByte(); switch (leadByte) { case 0xFB: return(-1); case 0xFC: return(reader.ReadFixedLengthUInt32(2)); case 0xFD: return(reader.ReadFixedLengthUInt32(3)); case 0xFE: return(checked ((long)reader.ReadFixedLengthUInt64(8))); default: return(leadByte); } }
public static void DumpLeaks(this IObjectDB db) { using (var tr = db.StartReadOnlyTransaction()) using (var visitor = new FindUnusedKeysVisitor()) { visitor.ImportAllKeys(tr); var iterator = visitor.Iterate(tr); visitor.DumpUnseenKeys(); var leakedObjects = new List <ulong>(); foreach (var unseenKey in visitor.UnseenKeys()) { if (unseenKey.Key[0] == 1) { try { var r = new ByteArrayReader(unseenKey.Key); r.SkipUInt8(); var oid = r.ReadVUInt64(); leakedObjects.Add(oid); } catch (Exception ex) { Console.WriteLine($"Leak found but error has occured while reading: {ex.Message}"); } } } if (leakedObjects.Count > 0) { Console.WriteLine("--- OBJECTS ---"); var consoleVisitor = new ToConsoleVisitorNice(); foreach (var oid in leakedObjects) { iterator.IterateUnseenOid(oid, consoleVisitor); Console.WriteLine("------"); } } } }
public bool NextKey(out TKey key) { if (!_seekNeeded) { _pos++; } if (_pos >= _count) { key = default(TKey); return(false); } _keyValueTrProtector.Start(); if (_keyValueTrProtector.WasInterupted(_prevProtectionCounter)) { _keyValueTr.SetKeyPrefix(_keyBytes); Seek(); } else if (_seekNeeded) { Seek(); } else { if (_ascending) { _keyValueTr.FindNextKey(); } else { _keyValueTr.FindPreviousKey(); } } //read key var keyData = _keyValueTr.GetKeyAsByteArray(); var reader = new ByteArrayReader(keyData); key = _keyReader(reader, null); return(true); }
public static ErrorPayload Create(PayloadData payload) { var reader = new ByteArrayReader(payload.ArraySegment); reader.ReadByte(Signature); var errorCode = reader.ReadUInt16(); var stateMarker = Encoding.ASCII.GetString(reader.ReadByteString(1)); string state, message; if (stateMarker == "#") { state = Encoding.ASCII.GetString(reader.ReadByteString(5)); message = Encoding.UTF8.GetString(reader.ReadByteString(payload.ArraySegment.Count - 9)); } else { state = "HY000"; message = stateMarker + Encoding.UTF8.GetString(reader.ReadByteString(payload.ArraySegment.Count - 4)); } return(new ErrorPayload(errorCode, state, message)); }
public async Task <int> BuildExistingCompressedChunk(ByteArrayReader reader, BulkDataCompressionTypes compressionFlags) { BulkDataFlags = (uint)compressionFlags; int builderSize = sizeof(uint) + sizeof(int) * 3; if ((compressionFlags & NothingToDo) > 0) { return(builderSize); } reader.Seek(0); UncompressedSize = reader.Remaining; builderSize += await Header.BuildExistingCompressedChunkHeader(reader, BulkDataFlags); CompressedSize = builderSize - 16; return(builderSize); }
public static ColumnDefinitionPayload Create(ResizableArraySegment <byte> arraySegment) { var reader = new ByteArrayReader(arraySegment); SkipLengthEncodedByteString(ref reader); // catalog SkipLengthEncodedByteString(ref reader); // schema SkipLengthEncodedByteString(ref reader); // table SkipLengthEncodedByteString(ref reader); // physical table SkipLengthEncodedByteString(ref reader); // name SkipLengthEncodedByteString(ref reader); // physical name reader.ReadByte(0x0C); // length of fixed-length fields, always 0x0C var characterSet = (CharacterSet)reader.ReadUInt16(); var columnLength = reader.ReadUInt32(); var columnType = (ColumnType)reader.ReadByte(); var columnFlags = (ColumnFlags)reader.ReadUInt16(); var decimals = reader.ReadByte(); // 0x00 for integers and static strings, 0x1f for dynamic strings, double, float, 0x00 to 0x51 for decimals reader.ReadByte(0); // reserved byte 1 reader.ReadByte(0); // reserved byte 2 return(new ColumnDefinitionPayload(arraySegment, characterSet, columnLength, columnType, columnFlags, decimals)); }
public override bool ServerDecode( ModbusCommand command, ByteArrayReader body) { if (body.CanRead(4)) { command.Offset = body.ReadUInt16BE(); command.Count = 1; command.QueryTotalLength += 4; command.Data = new ushort[1]; command.Data[0] = body.ReadUInt16BE() != 0 ? (ushort)0xFFFF : (ushort)0; return(true); } else { return(false); } }
public static AuthenticationMethodSwitchRequestPayload Create(PayloadData payload) { var reader = new ByteArrayReader(payload.ArraySegment); reader.ReadByte(Signature); string name; byte[] data; if (payload.ArraySegment.Count == 1) { // if the packet is just the header byte (0xFE), it's an "Old Authentication Method Switch Request Packet" // (possibly sent by a server that doesn't support CLIENT_PLUGIN_AUTH) name = "mysql_old_password"; data = new byte[0]; } else { name = Encoding.UTF8.GetString(reader.ReadNullTerminatedByteString()); data = reader.ReadByteArray(reader.BytesRemaining); } return(new AuthenticationMethodSwitchRequestPayload(name, data)); }
public static ErrorPayload Create(ReadOnlySpan <byte> span) { var reader = new ByteArrayReader(span); reader.ReadByte(Signature); var errorCode = reader.ReadUInt16(); var stateMarker = Encoding.ASCII.GetString(reader.ReadByteString(1)); string state, message; if (stateMarker == "#") { state = Encoding.ASCII.GetString(reader.ReadByteString(5)); message = Encoding.UTF8.GetString(reader.ReadByteString(span.Length - 9)); } else { state = "HY000"; message = stateMarker + Encoding.UTF8.GetString(reader.ReadByteString(span.Length - 4)); } return(new ErrorPayload(errorCode, state, message)); }
CommResponse IProtocolCodec.ServerDecode(CommDataBase data) { ModbusServer ownerProtocol = (ModbusServer)data.OwnerProtocol; ByteArrayReader incomingData = data.IncomingData; if (incomingData.Length >= 6) { ushort num1 = incomingData.ReadUInt16BE(); if (incomingData.ReadInt16BE() == (short)0) { short num2 = incomingData.ReadInt16BE(); if (incomingData.Length >= (int)num2 + 6) { if ((int)incomingData.ReadByte() == (int)ownerProtocol.Address) { byte fc = incomingData.ReadByte(); if ((int)fc >= ModbusCodecBase.CommandCodecs.Length) { throw new ApplicationException("Unknown function code"); } ModbusCommand command = new ModbusCommand(fc); data.UserData = (object)command; command.TransId = (int)num1; ByteArrayReader body = new ByteArrayReader(incomingData.ReadToEnd()); ModbusCodecBase.CommandCodecs[(int)fc]?.ServerDecode(command, body); return(new CommResponse(data, 3)); } } else { goto label_10; } } return(new CommResponse(data, 1)); } label_10: return(new CommResponse(data, 0)); }
private bool ReadAsyncRemainder(PayloadData payload) { if (payload.HeaderByte == EofPayload.Signature) { var eof = EofPayload.Create(payload); m_state = eof.ServerStatus.HasFlag(ServerStatus.MoreResultsExist) ? State.HasMoreData : State.NoMoreData; return false; } var reader = new ByteArrayReader(payload.ArraySegment); for (var column = 0; column < m_dataOffsets.Length; column++) { var length = checked((int) ReadFieldLength(reader)); m_dataLengths[column] = length == -1 ? 0 : length; m_dataOffsets[column] = length == -1 ? -1 : reader.Offset; reader.Offset += m_dataLengths[column]; } m_currentRow = payload.ArraySegment.Array; m_state = State.ReadingRows; return true; }
public string GetPrintScaleDescription() { try { var bytes = Directory.GetByteArray(PhotoshopDirectory.TagPrintScale); if (bytes == null) { return(null); } var reader = new ByteArrayReader(bytes); var style = reader.GetInt32(0); var locX = reader.GetFloat32(2); var locY = reader.GetFloat32(6); var scale = reader.GetFloat32(10); switch (style) { case 0: return($"Centered, Scale {scale:0.0##}"); case 1: return("Size to fit"); case 2: return($"User defined, X:{locX} Y:{locY}, Scale:{scale:0.0##}"); default: return($"Unknown {style:X4}, X:{locX} Y:{locY}, Scale:{scale:0.0##}"); } } catch { return(null); } }
private bool ReadAsyncRemainder(PayloadData payload) { if (EofPayload.IsEof(payload)) { var eof = EofPayload.Create(payload); m_state = eof.ServerStatus.HasFlag(ServerStatus.MoreResultsExist) ? State.HasMoreData : State.NoMoreData; return(false); } var reader = new ByteArrayReader(payload.ArraySegment); for (var column = 0; column < m_dataOffsets.Length; column++) { var length = checked ((int)ReadFieldLength(reader)); m_dataLengths[column] = length == -1 ? 0 : length; m_dataOffsets[column] = length == -1 ? -1 : reader.Offset; reader.Offset += m_dataLengths[column]; } m_currentRow = payload.ArraySegment.Array; m_state = State.ReadingRows; return(true); }
public async Task <int> BuildExistingCompressedChunkHeader(ByteArrayReader reader, uint flags) { Signature = Signatures.Signature; BlockSize = 0x00020000; CompressedSize = 0; UncompressedSize = reader.Remaining; int blockCount = (reader.Remaining + BlockSize - 1) / BlockSize; int builderSize = 0; for (int i = 0; i < blockCount; ++i) { builderSize += await Blocks[i].BuildExistingCompressedChunkBlockData(); CompressedSize += Blocks[i].CompressedSize; } builderSize += sizeof(uint) + sizeof(int) * 3; return(builderSize); }
/// <summary> /// Helper for unpacking discrete data incoming as a bit-array /// </summary> /// <param name="command"></param> /// <param name="body"></param> /// <returns>True if the data could be read</returns> internal static bool PopDiscretes( ModbusCommand command, ByteArrayReader body) { var success = false; if (body.CanRead(1)) { var byteCount = body.ReadByte(); if (body.CanRead(byteCount)) { var count = command.Count; command.Data = new ushort[count]; command.QueryTotalLength += (byteCount + 1); int k = 0; while (count > 0) { byteCount--; int cell = body.ReadByte(); int n = count <= 8 ? count : 8; count -= n; for (int i = 0; i < n; i++) { command.Data[k++] = (ushort)(cell & (1 << i)); } } success = true; } } return(success); }
public string GetResolutionInfoDescription() { try { var bytes = Directory.GetByteArray(PhotoshopDirectory.TagResolutionInfo); if (bytes == null) { return(null); } var reader = new ByteArrayReader(bytes); var resX = reader.GetS15Fixed16(0); var resY = reader.GetS15Fixed16(8); // is this the correct offset? it's only reading 4 bytes each time return($"{resX:0.##}x{resY:0.##} DPI"); } catch { return(null); } }
/// <summary>Version specifically for dealing with XMP found in JPEG segments.</summary> /// <remarks> /// Version specifically for dealing with XMP found in JPEG segments. This form of XMP has a peculiar preamble, which /// must be removed before parsing the XML. /// </remarks> /// <param name="segmentBytes">The byte array from which the metadata should be extracted.</param> /// <param name="metadata"> /// The /// <see cref="Com.Drew.Metadata.Metadata"/> /// object into which extracted values should be merged. /// </param> /// <param name="segmentType"> /// The /// <see cref="Com.Drew.Imaging.Jpeg.JpegSegmentType"/> /// being read. /// </param> public virtual void Extract(sbyte[] segmentBytes, Com.Drew.Metadata.Metadata metadata, JpegSegmentType segmentType) { XmpDirectory directory = metadata.GetOrCreateDirectory <XmpDirectory>(); // XMP in a JPEG file has a 29 byte preamble which is not valid XML. int preambleLength = 29; // check for the header length if (segmentBytes.Length <= preambleLength + 1) { directory.AddError(Sharpen.Extensions.StringFormat("Xmp data segment must contain at least %d bytes", preambleLength + 1)); return; } ByteArrayReader reader = new ByteArrayReader(segmentBytes); string preamble = Sharpen.Runtime.GetStringForBytes(segmentBytes, 0, preambleLength); if (!"http://ns.adobe.com/xap/1.0/\x0".Equals(preamble)) { directory.AddError("XMP data segment doesn't begin with 'http://ns.adobe.com/xap/1.0/'"); return; } sbyte[] xmlBytes = new sbyte[segmentBytes.Length - preambleLength]; System.Array.Copy(segmentBytes, 29, xmlBytes, 0, xmlBytes.Length); Extract(xmlBytes, metadata); }
public string GetSlicesDescription() { try { var bytes = Directory.GetByteArray(PhotoshopDirectory.TagSlices); if (bytes == null) { return(null); } var reader = new ByteArrayReader(bytes); var nameLength = reader.GetInt32(20); var name = reader.GetString(24, nameLength * 2, Encoding.BigEndianUnicode); var pos = 24 + nameLength * 2; var sliceCount = reader.GetInt32(pos); return($"{name} ({reader.GetInt32(4)},{reader.GetInt32(8)},{reader.GetInt32(12)},{reader.GetInt32(16)}) {sliceCount} Slices"); } catch { return(null); } }
public override void ServerDecode( ModbusCommand command, ByteArrayReader body) { _device = body.ReadByte(); var data_len = body.ReadByte(); body.ReadByte(); body.ReadByte(); _address = body.ReadInt32BE(); _dayIndex = _address & 0x03FF; _category = (_address & 0xFC00) >> 10; command.Count = data_len; command.Data = new ushort[command.Count]; }
private string GetTagDataString(int tagType) { try { sbyte[] bytes = _directory.GetByteArray(tagType); if (bytes == null) { return(_directory.GetString(tagType)); } RandomAccessReader reader = new ByteArrayReader(bytes); int iccTagType = reader.GetInt32(0); switch (iccTagType) { case IccTagTypeText: { try { return(Sharpen.Runtime.GetStringForBytes(bytes, 8, bytes.Length - 8 - 1, "ASCII")); } catch (UnsupportedEncodingException) { return(Sharpen.Runtime.GetStringForBytes(bytes, 8, bytes.Length - 8 - 1)); } goto case IccTagTypeDesc; } case IccTagTypeDesc: { int stringLength = reader.GetInt32(8); return(Sharpen.Runtime.GetStringForBytes(bytes, 12, stringLength - 1)); } case IccTagTypeSig: { return(IccReader.GetStringFromInt32(reader.GetInt32(8))); } case IccTagTypeMeas: { int observerType = reader.GetInt32(8); float x = reader.GetS15Fixed16(12); float y = reader.GetS15Fixed16(16); float z = reader.GetS15Fixed16(20); int geometryType = reader.GetInt32(24); float flare = reader.GetS15Fixed16(28); int illuminantType = reader.GetInt32(32); string observerString; switch (observerType) { case 0: { observerString = "Unknown"; break; } case 1: { observerString = "1931 2°"; break; } case 2: { observerString = "1964 10°"; break; } default: { observerString = Sharpen.Extensions.StringFormat("Unknown %d", observerType); break; } } string geometryString; switch (geometryType) { case 0: { geometryString = "Unknown"; break; } case 1: { geometryString = "0/45 or 45/0"; break; } case 2: { geometryString = "0/d or d/0"; break; } default: { geometryString = Sharpen.Extensions.StringFormat("Unknown %d", observerType); break; } } string illuminantString; switch (illuminantType) { case 0: { illuminantString = "unknown"; break; } case 1: { illuminantString = "D50"; break; } case 2: { illuminantString = "D65"; break; } case 3: { illuminantString = "D93"; break; } case 4: { illuminantString = "F2"; break; } case 5: { illuminantString = "D55"; break; } case 6: { illuminantString = "A"; break; } case 7: { illuminantString = "Equi-Power (E)"; break; } case 8: { illuminantString = "F8"; break; } default: { illuminantString = Sharpen.Extensions.StringFormat("Unknown %d", illuminantType); break; } } return(Sharpen.Extensions.StringFormat("%s Observer, Backing (%s, %s, %s), Geometry %s, Flare %d%%, Illuminant %s", observerString, x, y, z, geometryString, (long)System.Math.Round(flare * 100), illuminantString)); } case IccTagTypeXyzArray: { StringBuilder res = new StringBuilder(); int count = (bytes.Length - 8) / 12; for (int i = 0; i < count; i++) { float x = reader.GetS15Fixed16(8 + i * 12); float y = reader.GetS15Fixed16(8 + i * 12 + 4); float z = reader.GetS15Fixed16(8 + i * 12 + 8); if (i > 0) { res.Append(", "); } res.Append("(").Append(x).Append(", ").Append(y).Append(", ").Append(z).Append(")"); } return(Sharpen.Extensions.ConvertToString(res)); } case IccTagTypeMluc: { int int1 = reader.GetInt32(8); StringBuilder res = new StringBuilder(); res.Append(int1); //int int2 = reader.getInt32(12); //System.err.format("int1: %d, int2: %d\n", int1, int2); for (int i = 0; i < int1; i++) { string str = IccReader.GetStringFromInt32(reader.GetInt32(16 + i * 12)); int len = reader.GetInt32(16 + i * 12 + 4); int ofs = reader.GetInt32(16 + i * 12 + 8); string name; try { name = Sharpen.Runtime.GetStringForBytes(bytes, ofs, len, "UTF-16BE"); } catch (UnsupportedEncodingException) { name = Sharpen.Runtime.GetStringForBytes(bytes, ofs, len); } res.Append(" ").Append(str).Append("(").Append(name).Append(")"); } //System.err.format("% 3d: %s, len: %d, ofs: %d, \"%s\"\n", i, str, len,ofs,name); return(Sharpen.Extensions.ConvertToString(res)); } case IccTagTypeCurv: { int num = reader.GetInt32(8); StringBuilder res = new StringBuilder(); for (int i = 0; i < num; i++) { if (i != 0) { res.Append(", "); } res.Append(FormatDoubleAsString(((float)reader.GetUInt16(12 + i * 2)) / 65535.0, 7, false)); } //res+=String.format("%1.7g",Math.round(((float)iccReader.getInt16(b,12+i*2))/0.065535)/1E7); return(Sharpen.Extensions.ConvertToString(res)); } default: { return(Sharpen.Extensions.StringFormat("%s(0x%08X): %d bytes", IccReader.GetStringFromInt32(iccTagType), iccTagType, bytes.Length)); } } } catch (IOException) { // TODO decode these values during IccReader.extract so we can report any errors at that time // It is convention to return null if a description cannot be formulated. // If an error is to be reported, it should be done during the extraction process. return(null); } }
public override void ClientDecode(ModbusCommand command, ByteArrayReader body) { }
/// <summary> /// Decode the incoming data from the remote slave device /// to a client-side command /// </summary> /// <param name="command"></param> /// <param name="body"></param> public virtual void ClientDecode( ModbusCommand command, ByteArrayReader body) { }
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header) { await Task.Run(() => NameIndexValue.ReadNameTableIndex(reader, header)); }
public async Task <ResultSet> ReadResultSetHeaderAsync(IOBehavior ioBehavior, CancellationToken cancellationToken) { // ResultSet can be re-used, so initialize everything BufferState = ResultSetState.None; ColumnDefinitions = null; LastInsertId = 0; RecordsAffected = 0; State = ResultSetState.None; m_dataLengths = null; m_dataOffsets = null; m_readBuffer.Clear(); m_row = null; m_rowBuffered = null; while (true) { var payload = await Session.ReceiveReplyAsync(ioBehavior, cancellationToken).ConfigureAwait(false); var firstByte = payload.HeaderByte; if (firstByte == OkPayload.Signature) { var ok = OkPayload.Create(payload); RecordsAffected = ok.AffectedRowCount; LastInsertId = ok.LastInsertId; ColumnDefinitions = null; State = (ok.ServerStatus & ServerStatus.MoreResultsExist) == 0 ? ResultSetState.NoMoreData : ResultSetState.HasMoreData; if (State == ResultSetState.NoMoreData) { break; } } else if (firstByte == 0xFB) { throw new NotSupportedException("Don't support LOCAL_INFILE_Request"); } else { var reader = new ByteArrayReader(payload.ArraySegment); var columnCount = (int)reader.ReadLengthEncodedInteger(); ColumnDefinitions = new ColumnDefinitionPayload[columnCount]; m_dataOffsets = new int[columnCount]; m_dataLengths = new int[columnCount]; for (var column = 0; column < ColumnDefinitions.Length; column++) { payload = await Session.ReceiveReplyAsync(ioBehavior, cancellationToken).ConfigureAwait(false); ColumnDefinitions[column] = ColumnDefinitionPayload.Create(payload); } payload = await Session.ReceiveReplyAsync(ioBehavior, cancellationToken).ConfigureAwait(false); EofPayload.Create(payload); LastInsertId = -1; State = ResultSetState.ReadResultSetHeader; break; } } BufferState = State; return(this); }
public override void ClientDecode( ModbusCommand command, ByteArrayReader body) { //not used }
protected abstract int ReadFromByteArray(ByteArrayReader reader);
public int FromByteArray(byte[] bytes, int startIndex) { var reader = new ByteArrayReader(bytes, startIndex); return ReadFromByteArray(reader); }
public override async Task OpenAsync(CancellationToken cancellationToken) { VerifyNotDisposed(); if (State != ConnectionState.Closed) throw new InvalidOperationException("Cannot Open when State is {0}.".FormatInvariant(State)); #if !NETSTANDARD1_3 if (System.Transactions.Transaction.Current != null) throw new NotSupportedException("Ambient transactions are not supported. Use BeginTransaction instead."); #endif if (m_connectionStringBuilder.UseCompression) throw new NotSupportedException("Compression not supported."); SetState(ConnectionState.Connecting); bool success = false; try { var pool = ConnectionPool.GetPool(m_connectionStringBuilder); m_session = pool?.TryGetSession(); if (m_session == null) { m_session = new MySqlSession(pool); var connected = await m_session.ConnectAsync(m_connectionStringBuilder.Server.Split(','), (int) m_connectionStringBuilder.Port).ConfigureAwait(false); if (!connected) { SetState(ConnectionState.Closed); throw new MySqlException("Unable to connect to any of the specified MySQL hosts."); } var payload = await m_session.ReceiveAsync(cancellationToken).ConfigureAwait(false); var reader = new ByteArrayReader(payload.ArraySegment.Array, payload.ArraySegment.Offset, payload.ArraySegment.Count); var initialHandshake = new InitialHandshakePacket(reader); if (initialHandshake.AuthPluginName != "mysql_native_password") throw new NotSupportedException("Only 'mysql_native_password' authentication method is supported."); m_session.ServerVersion = new ServerVersion(Encoding.ASCII.GetString(initialHandshake.ServerVersion)); m_session.AuthPluginData = initialHandshake.AuthPluginData; var response = HandshakeResponse41Packet.Create(initialHandshake, m_connectionStringBuilder.UserID, m_connectionStringBuilder.Password, m_database); payload = new PayloadData(new ArraySegment<byte>(response)); await m_session.SendReplyAsync(payload, cancellationToken).ConfigureAwait(false); await m_session.ReceiveReplyAsync(cancellationToken).ConfigureAwait(false); // TODO: Check success } else if (m_connectionStringBuilder.ConnectionReset) { if (m_session.ServerVersion.Version.CompareTo(ServerVersions.SupportsResetConnection) >= 0) { await m_session.SendAsync(ResetConnectionPayload.Create(), cancellationToken).ConfigureAwait(false); var payload = await m_session.ReceiveReplyAsync(cancellationToken).ConfigureAwait(false); OkPayload.Create(payload); } else { // optimistically hash the password with the challenge from the initial handshake (supported by MariaDB; doesn't appear to be supported by MySQL) var hashedPassword = AuthenticationUtility.HashPassword(m_session.AuthPluginData, 0, m_connectionStringBuilder.Password); var payload = ChangeUserPayload.Create(m_connectionStringBuilder.UserID, hashedPassword, m_database); await m_session.SendAsync(payload, cancellationToken).ConfigureAwait(false); payload = await m_session.ReceiveReplyAsync(cancellationToken).ConfigureAwait(false); if (payload.HeaderByte == AuthenticationMethodSwitchRequestPayload.Signature) { // if the server didn't support the hashed password; rehash with the new challenge var switchRequest = AuthenticationMethodSwitchRequestPayload.Create(payload); if (switchRequest.Name != "mysql_native_password") throw new NotSupportedException("Only 'mysql_native_password' authentication method is supported."); hashedPassword = AuthenticationUtility.HashPassword(switchRequest.Data, 0, m_connectionStringBuilder.Password); payload = new PayloadData(new ArraySegment<byte>(hashedPassword)); await m_session.SendReplyAsync(payload, cancellationToken).ConfigureAwait(false); payload = await m_session.ReceiveReplyAsync(cancellationToken).ConfigureAwait(false); } OkPayload.Create(payload); } } m_hasBeenOpened = true; SetState(ConnectionState.Open); success = true; } catch (MySqlException) { SetState(ConnectionState.Closed); throw; } catch (SocketException ex) { SetState(ConnectionState.Closed); throw new MySqlException("Unable to connect to any of the specified MySQL hosts.", ex); } finally { if (!success) Utility.Dispose(ref m_session); } }
internal MemorizedPosition(ByteArrayReader owner, int pos, int end) { _owner = owner; _pos = pos; _end = end; }
public virtual async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header) { DataReader = await reader.ReadByteArray(size); }
protected override int ReadFromByteArray(ByteArrayReader reader) { base.ReadFromByteArray(reader); Username = reader.ReadString(); return reader.Index; }
CommResponse IProtocolCodec.ServerDecode(CommDataBase data) { var server = (ModbusServer)data.OwnerProtocol; var incoming = data.IncomingData; //validate header first if (incoming.Length < 6) { goto LabelUnknown; } //transaction-id var transId = incoming.ReadUInt16BE(); //protocol-identifier var protId = incoming.ReadInt16BE(); if (protId != 0) { goto LabelIgnore; } //message length var length = incoming.ReadInt16BE(); if (incoming.Length < (length + 6)) { goto LabelUnknown; } //address var address = incoming.ReadByte(); data.Address = server.AddressFromIncommingData ? address : server.Address; if (server.CanHandleIncommingData(address)) { //function code var fncode = incoming.ReadByte(); if (!CommandCodecs.ContainsKey(fncode)) { return(new CommResponse(null, CommResponse.Unknown)); } //create a new command var command = new ModbusCommand(fncode); data.UserData = command; command.TransId = transId; // var body = new ByteArrayReader(incoming.ReadToEnd()); //encode the command body, if applies var codec = CommandCodecs[fncode]; if (codec != null) { codec.ServerDecode(command, body); } return(new CommResponse( data, CommResponse.Ack)); } //exception LabelIgnore: return(new CommResponse( data, CommResponse.Ignore)); LabelUnknown: return(new CommResponse( data, CommResponse.Unknown)); }
public override async Task SetObject(string filename, List <DomainNameTableEntry> nameTable) { ImageEngineImage image = await Task.Run(() => new ImageEngineImage(filename)); int width = image.Width; int height = image.Height; DomainPropertyIntValue sizeX = PropertyHeader.GetProperty("SizeX").FirstOrDefault()?.Value as DomainPropertyIntValue; DomainPropertyIntValue sizeY = PropertyHeader.GetProperty("SizeY").FirstOrDefault()?.Value as DomainPropertyIntValue; sizeX?.SetPropertyValue(width); sizeY?.SetPropertyValue(height); DomainPropertyIntValue mipTailBaseIdx = PropertyHeader.GetProperty("MipTailBaseIdx").FirstOrDefault()?.Value as DomainPropertyIntValue; mipTailBaseIdx?.SetPropertyValue((int)Math.Log(width > height ? width : height, 2)); DomainPropertyStringValue filePath = PropertyHeader.GetProperty("SourceFilePath").FirstOrDefault()?.Value as DomainPropertyStringValue; DomainPropertyStringValue fileTime = PropertyHeader.GetProperty("SourceFileTimestamp").FirstOrDefault()?.Value as DomainPropertyStringValue; filePath?.SetPropertyValue(filename); fileTime?.SetPropertyValue(File.GetLastWriteTime(filename).ToString("yyyy-MM-dd hh:mm:ss")); DomainPropertyByteValue pfFormat = PropertyHeader.GetProperty("Format").FirstOrDefault()?.Value as DomainPropertyByteValue; ImageEngineFormat imageFormat = image.Format.InternalFormat; if (!imageFormat.ToString().Contains("DDS")) { throw new Exception($"Image is not in a DDS format. It is actually {imageFormat}."); } if (pfFormat != null) { string formatStr = imageFormat.ToString().Replace("DDS", "PF"); if (formatStr.Contains("ARGB")) { formatStr = "PF_A8R8G8B8"; } else if (formatStr.Contains("G8")) { formatStr = "PF_G8"; } DomainNameTableEntry formatTableEntry = nameTable.SingleOrDefault(nt => nt.Name.String == formatStr) ?? nameTable.AddDomainNameTableEntry(formatStr); pfFormat.SetPropertyValue(formatTableEntry); } MipMaps.Clear(); while (true) { MemoryStream stream = new MemoryStream(); image.Save(stream, imageFormat, MipHandling.KeepTopOnly); await stream.FlushAsync(); MipMaps.Add(new DomainMipMap { ImageData = (await ByteArrayReader.CreateNew(stream.ToArray(), 0x80).Splice()).GetBytes(), // Strip off 128 bytes for the DDS header Width = image.Width, Height = image.Height }); if (width == 1 && height == 1) { break; } if (width > 1) { width /= 2; } if (height > 1) { height /= 2; } if (image.Width > 4 && image.Height > 4) { image.Resize(0.5, false); } } }
/// <summary> /// Decode the incoming data from the remote master device /// to a server-side command /// </summary> /// <param name="command"></param> /// <param name="body"></param> public virtual void ServerDecode( ModbusCommand command, ByteArrayReader body) { }
static Row?ScanRowAsyncRemainder(ResultSet this_, PayloadData payload, Row?row_) { if (payload.HeaderByte == EofPayload.Signature) { var span = payload.Span; if (this_.Session.SupportsDeprecateEof && OkPayload.IsOk(span, this_.Session.SupportsDeprecateEof)) { var ok = OkPayload.Create(span, this_.Session.SupportsDeprecateEof, this_.Session.SupportsSessionTrack); this_.BufferState = (ok.ServerStatus & ServerStatus.MoreResultsExist) == 0 ? ResultSetState.NoMoreData : ResultSetState.HasMoreData; return(null); } if (!this_.Session.SupportsDeprecateEof && EofPayload.IsEof(payload)) { var eof = EofPayload.Create(span); this_.BufferState = (eof.ServerStatus & ServerStatus.MoreResultsExist) == 0 ? ResultSetState.NoMoreData : ResultSetState.HasMoreData; return(null); } } if (row_ is null) { bool isBinaryRow = false; if (payload.HeaderByte == 0 && !this_.Connection.IgnorePrepare) { // this might be a binary row, but it might also be a text row whose first column is zero bytes long; try reading // the row as a series of length-encoded values (the text format) to see if this might plausibly be a text row var isTextRow = false; var reader = new ByteArrayReader(payload.Span); var columnCount = 0; while (reader.BytesRemaining > 0) { int length; var firstByte = reader.ReadByte(); if (firstByte == 0xFB) { // NULL length = 0; } else if (firstByte == 0xFC) { // two-byte length-encoded integer if (reader.BytesRemaining < 2) { break; } length = unchecked ((int)reader.ReadFixedLengthUInt32(2)); } else if (firstByte == 0xFD) { // three-byte length-encoded integer if (reader.BytesRemaining < 3) { break; } length = unchecked ((int)reader.ReadFixedLengthUInt32(3)); } else if (firstByte == 0xFE) { // eight-byte length-encoded integer if (reader.BytesRemaining < 8) { break; } length = checked ((int)reader.ReadFixedLengthUInt64(8)); } else if (firstByte == 0xFF) { // invalid length prefix break; } else { // single-byte length length = firstByte; } if (reader.BytesRemaining < length) { break; } reader.Offset += length; columnCount++; if (columnCount == this_.ColumnDefinitions !.Length) { // if we used up all the bytes reading exactly 'ColumnDefinitions' length-encoded columns, then assume this is a text row if (reader.BytesRemaining == 0) { isTextRow = true; } break; } } isBinaryRow = !isTextRow; } row_ = isBinaryRow ? (Row) new BinaryRow(this_) : new TextRow(this_); } row_.SetData(payload.Memory); this_.m_hasRows = true; this_.BufferState = ResultSetState.ReadingRows; return(row_); }
CommResponse IProtocolCodec.ServerDecode(CommDataBase data) { var server = (ModbusServer)data.OwnerProtocol; var incoming = data.IncomingData; //validate header first var length = incoming.Length; if (length < 4) { goto LabelUnknown; } //address var address = incoming.ReadByte(); if (address == server.Address) { //function code var fncode = incoming.ReadByte(); if (fncode < CommandCodecs.Length) { //create a new command var command = new ModbusCommand(fncode); data.UserData = command; command.QueryTotalLength = 6; //= addr + fn + offset + crc //get the command codec var codec = CommandCodecs[fncode]; //decode the command, where possible var body = new ByteArrayReader(incoming.ReadBytes(length - 4)); codec.ServerDecode(command, body); //calculate the CRC-16 over the received stream ushort crcCalc = ByteArrayHelpers.CalcCRC16( incoming.ToArray(), 0, command.QueryTotalLength - 2); //validate the CRC-16 var crcRead = ByteArrayHelpers.ReadInt16LE( ((IByteArray)incoming).Data, command.QueryTotalLength - 2); if (crcRead == (short)crcCalc) { return(new CommResponse( data, CommResponse.Ack)); } } } //exception return(new CommResponse( data, CommResponse.Ignore)); LabelUnknown: return(new CommResponse( data, CommResponse.Unknown)); }
public async Task ReadResultSetHeaderAsync(IOBehavior ioBehavior) { Reset(); try { while (true) { var payload = await Session.ReceiveReplyAsync(ioBehavior, CancellationToken.None).ConfigureAwait(false); var firstByte = payload.HeaderByte; if (firstByte == OkPayload.Signature) { var ok = OkPayload.Create(payload.Span, Session.SupportsDeprecateEof, Session.SupportsSessionTrack); RecordsAffected = (RecordsAffected ?? 0) + ok.AffectedRowCount; LastInsertId = unchecked ((long)ok.LastInsertId); WarningCount = ok.WarningCount; if (ok.NewSchema is object) { Connection.Session.DatabaseOverride = ok.NewSchema; } ColumnDefinitions = null; ColumnTypes = null; State = (ok.ServerStatus & ServerStatus.MoreResultsExist) == 0 ? ResultSetState.NoMoreData : ResultSetState.HasMoreData; if (State == ResultSetState.NoMoreData) { break; } } else if (firstByte == LocalInfilePayload.Signature) { try { if (!Connection.AllowLoadLocalInfile) { throw new NotSupportedException("To use LOAD DATA LOCAL INFILE, set AllowLoadLocalInfile=true in the connection string. See https://fl.vu/mysql-load-data"); } var localInfile = LocalInfilePayload.Create(payload.Span); if (!IsHostVerified(Connection) && !localInfile.FileName.StartsWith(MySqlBulkLoader.StreamPrefix, StringComparison.Ordinal)) { throw new NotSupportedException("Use SourceStream or SslMode >= VerifyCA for LOAD DATA LOCAL INFILE. See https://fl.vu/mysql-load-data"); } using var stream = localInfile.FileName.StartsWith(MySqlBulkLoader.StreamPrefix, StringComparison.Ordinal) ? MySqlBulkLoader.GetAndRemoveStream(localInfile.FileName) : File.OpenRead(localInfile.FileName); var readBuffer = new byte[65536]; int byteCount; while ((byteCount = await stream.ReadAsync(readBuffer, 0, readBuffer.Length).ConfigureAwait(false)) > 0) { payload = new PayloadData(new ArraySegment <byte>(readBuffer, 0, byteCount)); await Session.SendReplyAsync(payload, ioBehavior, CancellationToken.None).ConfigureAwait(false); } } catch (Exception ex) { // store the exception, to be thrown after reading the response packet from the server ReadResultSetHeaderException = new MySqlException("Error during LOAD DATA LOCAL INFILE", ex); } await Session.SendReplyAsync(EmptyPayload.Instance, ioBehavior, CancellationToken.None).ConfigureAwait(false); } else { int ReadColumnCount(ReadOnlySpan <byte> span) { var reader = new ByteArrayReader(span); var columnCount_ = (int)reader.ReadLengthEncodedInteger(); if (reader.BytesRemaining != 0) { throw new MySqlException("Unexpected data at end of column_count packet; see https://github.com/mysql-net/MySqlConnector/issues/324"); } return(columnCount_); } var columnCount = ReadColumnCount(payload.Span); // reserve adequate space to hold a copy of all column definitions (but note that this can be resized below if we guess too small) Utility.Resize(ref m_columnDefinitionPayloads, columnCount * 96); ColumnDefinitions = new ColumnDefinitionPayload[columnCount]; ColumnTypes = new MySqlDbType[columnCount]; for (var column = 0; column < ColumnDefinitions.Length; column++) { payload = await Session.ReceiveReplyAsync(ioBehavior, CancellationToken.None).ConfigureAwait(false); var payloadLength = payload.Span.Length; // 'Session.ReceiveReplyAsync' reuses a shared buffer; make a copy so that the column definitions can always be safely read at any future point if (m_columnDefinitionPayloadUsedBytes + payloadLength > m_columnDefinitionPayloads.Count) { Utility.Resize(ref m_columnDefinitionPayloads, m_columnDefinitionPayloadUsedBytes + payloadLength); } payload.Span.CopyTo(m_columnDefinitionPayloads.Array.AsSpan().Slice(m_columnDefinitionPayloadUsedBytes)); var columnDefinition = ColumnDefinitionPayload.Create(new ResizableArraySegment <byte>(m_columnDefinitionPayloads, m_columnDefinitionPayloadUsedBytes, payloadLength)); ColumnDefinitions[column] = columnDefinition; ColumnTypes[column] = TypeMapper.ConvertToMySqlDbType(columnDefinition, treatTinyAsBoolean: Connection.TreatTinyAsBoolean, guidFormat: Connection.GuidFormat); m_columnDefinitionPayloadUsedBytes += payloadLength; } if (!Session.SupportsDeprecateEof) { payload = await Session.ReceiveReplyAsync(ioBehavior, CancellationToken.None).ConfigureAwait(false); EofPayload.Create(payload.Span); } if (ColumnDefinitions.Length == (Command?.OutParameters?.Count + 1) && ColumnDefinitions[0].Name == SingleCommandPayloadCreator.OutParameterSentinelColumnName) { ContainsCommandParameters = true; } LastInsertId = -1; WarningCount = 0; State = ResultSetState.ReadResultSetHeader; break; } } } catch (Exception ex) { ReadResultSetHeaderException = ex; } finally { BufferState = State; } }
private static void SkipLengthEncodedByteString(ref ByteArrayReader reader) { var length = checked ((int)reader.ReadLengthEncodedInteger()); reader.Offset += length; }