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);
}
/// <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 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;
}
/// <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)
{
}
