private IEnumerable <IToken> ParseInternal(Stream stream, DbEnvironment env)
{
IFormatToken previousFormatToken = null;
while (stream.Position < stream.Length)
{
var tokenType = (TokenType)stream.ReadByte();
if (Readers.ContainsKey(tokenType))
{
var t = Readers[tokenType](stream, env, previousFormatToken);
if (t is IFormatToken token)
{
Logger.Instance?.WriteLine($"**Set new format token**");
previousFormatToken = token;
}
yield return(t);
}
else
{
Logger.Instance?.WriteLine($"!!! Hit unknown token type {tokenType} !!!");
var t = new CatchAllToken(tokenType);
t.Read(stream, env, previousFormatToken);
yield return(t);
}
}
}
private static object ReadTDS_BIGDATETIMEN(Stream stream, FormatItem format, DbEnvironment env)
{
switch (stream.ReadByte())
{
case 8: return(stream.ReadBigDateTime());
}
return(DBNull.Value);
}
private static object ReadInternal(Stream stream, FormatItem format, DbEnvironment env)
{
if (ReadMap.ContainsKey(format.DataType))
{
return(ReadMap[format.DataType](stream, format, env) ?? DBNull.Value);
}
Debug.Assert(false, $"Unsupported data type {format.DataType}");
return(DBNull.Value); // Catch-all.
}
private InternalConnection CreateConnectionInternal(Stream networkStream)
{
var environment = new DbEnvironment();
var reader = new TokenReader();
#if ENABLE_ARRAY_POOL
return(new InternalConnection(_parameters, networkStream, reader, environment, _arrayPool));
#else
return(new InternalConnection(_parameters, networkStream, reader, environment));
#endif
}
public TokenSendStream(Stream innerStream, DbEnvironment environment)
#endif
{
_innerStream = innerStream;
_innerWriteBufferStream = new MemoryStream();
_environment = environment;
_isDisposed = false;
#if ENABLE_ARRAY_POOL
_arrayPool = arrayPool;
#endif
}
private static object ReadTDS_DATEN(Stream stream, FormatItem format, DbEnvironment env)
{
switch (stream.ReadByte())
{
case 0: return(DBNull.Value);
case 4:
return(stream.ReadDate());
}
return(DBNull.Value);
}
/// <summary>
/// TDS_LONGBINARY serialization 55 serialized java object or instance (i.e. java object)
/// TDS_LONGBINARY serialized java class 56 serialized java class (i.e. byte code)
/// TDS_LONGBINARY smallbinary 59 64K max length binary data (ASA)
/// TDS_LONGBINARY unichar 34 fixed length UTF-16 encoded data
/// TDS_LONGBINARY univarchar 35 variable length UTF-16 encoded data
/// </summary>
private static object ReadTDS_LONGBINARY(Stream stream, FormatItem format, DbEnvironment env)
{
//the UserType can affect how we need to interpret the result data
switch (format.UserType)
{
case 34:
case 35:
return(stream.ReadNullableIntLengthPrefixedString(Encoding.Unicode));
default:
return(stream.ReadNullableIntLengthPrefixedByteArray());
}
}
public InternalConnection(IConnectionParameters parameters, Stream networkStream, ITokenReader reader, DbEnvironment environment)
#endif
{
_parameters = parameters;
_networkStream = networkStream;
_reader = reader;
_environment = environment;
_environment.PacketSize = parameters.PacketSize; //server might decide to change the packet size later anyway
_environment.UseAseDecimal = parameters.UseAseDecimal;
_sendMutex = new object();
#if ENABLE_ARRAY_POOL
_arrayPool = arrayPool;
#endif
}
private static object ReadTDS_UNITEXT(Stream stream, FormatItem format, DbEnvironment env)
{
var textPtrLen = (byte)stream.ReadByte();
if (textPtrLen <= 0)
{
return(DBNull.Value);
}
var textPtr = new byte[textPtrLen];
stream.Read(textPtr, 0, textPtrLen);
stream.ReadULong(); //timestamp
return(stream.ReadNullableIntLengthPrefixedString(Encoding.Unicode));
}
private static object ReadTDS_NUMN(Stream stream, FormatItem format, DbEnvironment env)
{
var precision = format.Precision ?? 1;
var scale = format.Scale ?? 0;
Logger.Instance?.WriteLine($" <- {format.DisplayColumnName} ({precision}, {scale})");
var aseDecimal = stream.ReadAseDecimal(precision, scale);
return(aseDecimal.HasValue
? env.UseAseDecimal
? (object)aseDecimal.Value
: aseDecimal.Value.ToDecimal()
: DBNull.Value);
}
private static object ReadTDS_MONEYN(Stream stream, FormatItem format, DbEnvironment env)
{
switch (stream.ReadByte())
{
case 0: return(DBNull.Value);
case 4:
return(stream.ReadSmallMoney());
case 8:
return(stream.ReadMoney());
}
return(DBNull.Value);
}
private static object ReadTDS_INTN(Stream stream, FormatItem format, DbEnvironment env)
{
switch (stream.ReadByte())
{
case 0: return(DBNull.Value);
case 1: return((byte)stream.ReadByte()); //both INTN(1) and UINTN(1) are an INT1. Never an SINT1.
case 2: return(stream.ReadShort());
case 4: return(stream.ReadInt());
case 8: return(stream.ReadLong());
}
return(DBNull.Value);
}
private static object ReadTDS_UINTN(Stream stream, FormatItem format, DbEnvironment env)
{
switch (stream.ReadByte())
{
case 0: return(DBNull.Value);
case 1: return((byte)stream.ReadByte());
case 2: return(stream.ReadUShort());
case 4: return(stream.ReadUInt());
case 8: return(stream.ReadULong());
}
return(DBNull.Value);
}
public void SendPacket(IPacket packet, DbEnvironment env)
{
lock (_sendMutex)
{
try
{
using (var ms = new MemoryStream())
{
packet.Write(ms, env);
ms.Seek(0, SeekOrigin.Begin);
if (ms.Length == 0)
{
//eg for cancel tokens
SendJustHeader(packet);
return;
}
while (ms.Position < ms.Length)
{
//split into chunks and send over the wire
var buffer = new byte[env.PacketSize];
var template = HeaderTemplate(packet.Type);
Array.Copy(template, buffer, template.Length);
var copied = ms.Read(buffer, template.Length, buffer.Length - template.Length);
var chunkLength = template.Length + copied;
buffer[1] = (byte)((ms.Position >= ms.Length ? BufferStatus.TDS_BUFSTAT_EOM : BufferStatus.TDS_BUFSTAT_NONE) | packet.Status);
buffer[2] = (byte)(chunkLength >> 8);
buffer[3] = (byte)chunkLength;
DumpBytes(buffer, chunkLength);
_inner.EnsureSend(buffer, 0, chunkLength);
}
}
}
finally
{
LastActive = DateTime.UtcNow;
}
}
}
public IToken[] ReceiveTokens(DbEnvironment env)
{
using (var ms = new MemoryStream())
{
bool canceled;
var buffer = new byte[env.PacketSize];
while (true)
{
_inner.EnsureReceive(buffer, 0, env.HeaderSize);
var length = buffer[2] << 8 | buffer[3];
var bufferStatus = (BufferStatus)buffer[1];
_inner.EnsureReceive(buffer, env.HeaderSize, length - env.HeaderSize);
ms.Write(buffer, env.HeaderSize, length - env.HeaderSize);
//" If TDS_BUFSTAT_ATTNACK not also TDS_BUFSTAT_EOM, continue reading packets until TDS_BUFSTAT_EOM."
canceled = bufferStatus.HasFlag(BufferStatus.TDS_BUFSTAT_ATTNACK) || bufferStatus.HasFlag(BufferStatus.TDS_BUFSTAT_ATTN);
if (bufferStatus.HasFlag(BufferStatus.TDS_BUFSTAT_EOM))
{
break;
}
}
if (canceled)
{
Logger.Instance?.WriteLine($"{nameof(RegularSocket)} - received cancel status flag");
return(new IToken[]
{
new DoneToken
{
Count = 0,
Status = DoneToken.DoneStatus.TDS_DONE_ATTN
}
});
}
ms.Seek(0, SeekOrigin.Begin);
LastActive = DateTime.UtcNow;
return(_parser.Parse(ms, env));
}
}
public IEnumerable <IToken> Read(TokenReceiveStream stream, DbEnvironment env)
{
IFormatToken previousFormatToken = null;
while (stream.DataAvailable)
{
var rawTokenType = (byte)stream.ReadByte();
var tokenType = (TokenType)rawTokenType;
if (Readers.ContainsKey(tokenType))
{
var t = Readers[tokenType](stream, env, previousFormatToken);
if (t is IFormatToken token)
{
Logger.Instance?.WriteLine($"**Set new format token**");
previousFormatToken = token;
}
yield return(t);
}
else
{
Logger.Instance?.WriteLine($"!!! Hit unknown token type {tokenType} !!!");
var t = new CatchAllToken(rawTokenType);
t.Read(stream, env, previousFormatToken);
yield return(t);
}
if (stream.IsCancelled)
{
Logger.Instance?.WriteLine($"{nameof(TokenReceiveStream)} - received cancel status flag");
yield return
(new DoneToken
{
Count = 0,
Status = DoneToken.DoneStatus.TDS_DONE_ATTN
});
}
}
}
public TokenReceiveStream(Stream innerStream, DbEnvironment environment)
#endif
{
_innerStream = innerStream;
_environment = environment;
_headerReadBufferLength = environment.HeaderSize;
#if ENABLE_ARRAY_POOL
_arrayPool = arrayPool;
_headerReadBuffer = arrayPool.Rent(_headerReadBufferLength);
_bodyReadBuffer = arrayPool.Rent(_environment.PacketSize - _headerReadBufferLength);
#else
_headerReadBuffer = new byte[_headerReadBufferLength];
_bodyReadBuffer = new byte[_environment.PacketSize - _headerReadBufferLength];
#endif
_bodyReadBufferPosition = 0;
_bodyReadBufferLength = 0;
IsCancelled = false;
_isDisposed = false;
_readBufferHasBytes = false;
_innerStreamHasBytes = true;
}
private static object ReadTDS_IMAGE(Stream stream, FormatItem format, DbEnvironment env)
{
var textPtrLen = (byte)stream.ReadByte();
if (textPtrLen == 0)
{
return(DBNull.Value);
}
var textPtr = new byte[textPtrLen];
stream.Read(textPtr, 0, textPtrLen);
stream.ReadULong(); //timestamp
var dataLen = stream.ReadInt();
if (dataLen <= 0)
{
return(DBNull.Value);
}
var data = new byte[dataLen];
stream.Read(data, 0, dataLen);
return(data);
}
public TokenReceiveStream(Stream innerStream, DbEnvironment environment, System.Buffers.ArrayPool <byte> arrayPool)
private static object ReadTDS_TIME(Stream stream, FormatItem format, DbEnvironment env)
{
return(stream.ReadTime());
}
private static object ReadInternal(Stream stream, FormatItem format, DbEnvironment env)
{
switch (format.DataType)
{
case TdsDataType.TDS_BIT:
return(stream.ReadBool());
case TdsDataType.TDS_INT1:
return((byte)stream.ReadByte());
case TdsDataType.TDS_SINT1:
return((sbyte)stream.ReadByte());
case TdsDataType.TDS_INT2:
return(stream.ReadShort());
case TdsDataType.TDS_UINT2:
return(stream.ReadUShort());
case TdsDataType.TDS_INT4:
return(stream.ReadInt());
case TdsDataType.TDS_UINT4:
return(stream.ReadUInt());
case TdsDataType.TDS_INT8:
return(stream.ReadLong());
case TdsDataType.TDS_UINT8:
return(stream.ReadULong());
case TdsDataType.TDS_INTN:
switch (stream.ReadByte())
{
case 0: return(DBNull.Value);
case 1: return((byte)stream.ReadByte()); //both INTN(1) and UINTN(1) are an INT1. Never an SINT1.
case 2: return(stream.ReadShort());
case 4: return(stream.ReadInt());
case 8: return(stream.ReadLong());
}
break;
case TdsDataType.TDS_UINTN:
switch (stream.ReadByte())
{
case 0: return(DBNull.Value);
case 1: return((byte)stream.ReadByte());
case 2: return(stream.ReadUShort());
case 4: return(stream.ReadUInt());
case 8: return(stream.ReadULong());
}
break;
case TdsDataType.TDS_FLT4:
return(stream.ReadFloat());
case TdsDataType.TDS_FLT8:
return(stream.ReadDouble());
case TdsDataType.TDS_FLTN:
switch (stream.ReadByte())
{
case 0: return(DBNull.Value);
case 4: return(stream.ReadFloat());
case 8: return(stream.ReadDouble());
}
break;
case TdsDataType.TDS_CHAR:
case TdsDataType.TDS_VARCHAR:
case TdsDataType.TDS_BOUNDARY:
case TdsDataType.TDS_SENSITIVITY:
return(stream.ReadNullableByteLengthPrefixedString(env.Encoding));
case TdsDataType.TDS_BINARY:
case TdsDataType.TDS_VARBINARY:
return(stream.ReadNullableByteLengthPrefixedByteArray());
case TdsDataType.TDS_LONGCHAR:
return(stream.ReadNullableIntLengthPrefixedString(env.Encoding));
/*
* TDS_LONGBINARY serialization 55 serialized java object or instance (i.e. java object)
* TDS_LONGBINARY serialized java class 56 serialized java class (i.e. byte code)
* TDS_LONGBINARY smallbinary 59 64K max length binary data (ASA)
* TDS_LONGBINARY unichar 34 fixed length UTF-16 encoded data
* TDS_LONGBINARY univarchar 35 variable length UTF-16 encoded data
*/
case TdsDataType.TDS_LONGBINARY:
{
//the UserType can affect how we need to interpret the result data
switch (format.UserType)
{
case 34:
case 35:
return(stream.ReadNullableIntLengthPrefixedString(Encoding.Unicode));
default:
return(stream.ReadNullableIntLengthPrefixedByteArray());
}
}
case TdsDataType.TDS_DECN:
case TdsDataType.TDS_NUMN:
{
var precision = format.Precision ?? 1;
var scale = format.Scale ?? 0;
Logger.Instance?.WriteLine($" <- {format.DisplayColumnName} ({precision}, {scale})");
var aseDecimal = stream.ReadAseDecimal(precision, scale);
return(aseDecimal.HasValue
? env.UseAseDecimal
? (object)aseDecimal.Value
: aseDecimal.Value.ToDecimal()
: DBNull.Value);
}
case TdsDataType.TDS_MONEY:
return(stream.ReadMoney());
case TdsDataType.TDS_SHORTMONEY:
return(stream.ReadSmallMoney());
case TdsDataType.TDS_MONEYN:
switch (stream.ReadByte())
{
case 0: return(DBNull.Value);
case 4:
return(stream.ReadSmallMoney());
case 8:
return(stream.ReadMoney());
}
break;
case TdsDataType.TDS_DATETIME:
return(stream.ReadIntPartDateTime());
case TdsDataType.TDS_SHORTDATE:
return(stream.ReadShortPartDateTime());
case TdsDataType.TDS_DATETIMEN:
switch (stream.ReadByte())
{
case 0: return(DBNull.Value);
case 4:
return(stream.ReadShortPartDateTime());
case 8:
return(stream.ReadIntPartDateTime());
}
break;
case TdsDataType.TDS_DATE:
return(stream.ReadDate());
case TdsDataType.TDS_DATEN:
switch (stream.ReadByte())
{
case 0: return(DBNull.Value);
case 4:
return(stream.ReadDate());
}
break;
case TdsDataType.TDS_TIME:
return(stream.ReadTime());
case TdsDataType.TDS_TIMEN:
switch (stream.ReadByte())
{
case 0: return(DBNull.Value);
case 4:
return(stream.ReadTime());
}
break;
case TdsDataType.TDS_TEXT:
case TdsDataType.TDS_XML:
{
var textPtrLen = (byte)stream.ReadByte();
if (textPtrLen == 0)
{
return(DBNull.Value);
}
var textPtr = new byte[textPtrLen];
stream.Read(textPtr, 0, textPtrLen);
stream.ReadULong(); //timestamp
return(stream.ReadNullableIntLengthPrefixedString(env.Encoding));
}
case TdsDataType.TDS_IMAGE:
{
var textPtrLen = (byte)stream.ReadByte();
if (textPtrLen == 0)
{
return(DBNull.Value);
}
var textPtr = new byte[textPtrLen];
stream.Read(textPtr, 0, textPtrLen);
stream.ReadULong(); //timestamp
var dataLen = stream.ReadInt();
if (dataLen == 0)
{
return(DBNull.Value);
}
var data = new byte[dataLen];
stream.Read(data, 0, dataLen);
return(data);
}
case TdsDataType.TDS_UNITEXT:
{
var textPtrLen = (byte)stream.ReadByte();
if (textPtrLen == 0)
{
return(DBNull.Value);
}
var textPtr = new byte[textPtrLen];
stream.Read(textPtr, 0, textPtrLen);
stream.ReadULong(); //timestamp
return(stream.ReadNullableIntLengthPrefixedString(Encoding.Unicode));
}
default:
Debug.Assert(false, $"Unsupported data type {format.DataType}");
break;
}
return(DBNull.Value); // Catch-all.
}
public static object Read(Stream stream, FormatItem format, DbEnvironment env)
{
return(ReadInternal(stream, format, env) ?? DBNull.Value);
}
public IToken[] Parse(Stream stream, DbEnvironment env)
{
return(new List <IToken>(ParseInternal(stream, env)).ToArray());
}
private static object ReadTDS_SHORTMONEY(Stream stream, FormatItem format, DbEnvironment env)
{
return(stream.ReadSmallMoney());
}
private static object ReadTDS_BIT(Stream stream, FormatItem format, DbEnvironment env)
{
return(stream.ReadBool());
}
private static object ReadTDS_UINT2(Stream stream, FormatItem format, DbEnvironment env)
{
return(stream.ReadUShort());
}
public InternalConnection(IConnectionParameters parameters, Stream networkStream, ITokenReader reader, DbEnvironment environment, System.Buffers.ArrayPool <byte> arrayPool)
private static object ReadTDS_INT4(Stream stream, FormatItem format, DbEnvironment env)
{
return(stream.ReadInt());
}
private static object ReadTDS_SINT1(Stream stream, FormatItem format, DbEnvironment env)
{
return((sbyte)stream.ReadByte());
}
private static object ReadTDS_SHORTDATE(Stream stream, FormatItem format, DbEnvironment env)
{
return(stream.ReadShortPartDateTime());
}
