public bool Unpack(MemoryStream stream)
{
HostNamePosition = LittleEndianUtilities.ReadUShort(stream);
HostNameLength = LittleEndianUtilities.ReadUShort(stream);
UserNamePosition = LittleEndianUtilities.ReadUShort(stream);
UserNameLength = LittleEndianUtilities.ReadUShort(stream);
PasswordPosition = LittleEndianUtilities.ReadUShort(stream);
PasswordLength = LittleEndianUtilities.ReadUShort(stream);
AppNamePosition = LittleEndianUtilities.ReadUShort(stream);
AppNameLength = LittleEndianUtilities.ReadUShort(stream);
ServerNamePosition = LittleEndianUtilities.ReadUShort(stream);
ServerNameLength = LittleEndianUtilities.ReadUShort(stream);
ExtensionPosition = LittleEndianUtilities.ReadUShort(stream);
ExtensionLength = LittleEndianUtilities.ReadUShort(stream);
CltIntNamePosition = LittleEndianUtilities.ReadUShort(stream);
CltIntNameLength = LittleEndianUtilities.ReadUShort(stream);
LanguagePosition = LittleEndianUtilities.ReadUShort(stream);
LanguageLength = LittleEndianUtilities.ReadUShort(stream);
DatabasePosition = LittleEndianUtilities.ReadUShort(stream);
DatabaseLength = LittleEndianUtilities.ReadUShort(stream);
stream.Read(ClientID, 0, 6);
SSPIPosition = LittleEndianUtilities.ReadUShort(stream);
SSPILength = LittleEndianUtilities.ReadUShort(stream);
AtchDBFilePosition = LittleEndianUtilities.ReadUShort(stream);
AtchDBFileLength = LittleEndianUtilities.ReadUShort(stream);
ChangePasswordPosition = LittleEndianUtilities.ReadUShort(stream);
ChangePasswordLength = LittleEndianUtilities.ReadUShort(stream);
SSPILengthLong = LittleEndianUtilities.ReadUInt(stream);
return(true);
}
/// <summary>
/// Used to unpack IPackageable from a stream.
/// </summary>
/// <param name="stream">MemoryStream from which to unpack IPackageable.</param>
/// <returns>Returns true if successful.</returns>
public override bool Unpack(MemoryStream stream)
{
LittleEndianUtilities.ReadUShort(stream);
this.Number = (int)LittleEndianUtilities.ReadUInt(stream);
this.State = Convert.ToByte(stream.ReadByte());
this.Class = Convert.ToByte(stream.ReadByte());
int length = LittleEndianUtilities.ReadUShort(stream) * 2;
var buffer = new byte[length];
stream.Read(buffer, 0, length);
this.MsgText = Encoding.Unicode.GetString(buffer);
length = stream.ReadByte() * 2;
buffer = new byte[length];
stream.Read(buffer, 0, length);
this.ServerName = Encoding.Unicode.GetString(buffer);
length = stream.ReadByte() * 2;
buffer = new byte[length];
stream.Read(buffer, 0, length);
this.ProcName = Encoding.Unicode.GetString(buffer);
this.LineNumber = LittleEndianUtilities.ReadUInt(stream);
return(true);
}
public void Pack(MemoryStream stream)
{
LittleEndianUtilities.WriteUShort(stream, HostNamePosition);
LittleEndianUtilities.WriteUShort(stream, HostNameLength);
LittleEndianUtilities.WriteUShort(stream, UserNamePosition);
LittleEndianUtilities.WriteUShort(stream, UserNameLength);
LittleEndianUtilities.WriteUShort(stream, PasswordPosition);
LittleEndianUtilities.WriteUShort(stream, PasswordLength);
LittleEndianUtilities.WriteUShort(stream, AppNamePosition);
LittleEndianUtilities.WriteUShort(stream, AppNameLength);
LittleEndianUtilities.WriteUShort(stream, ServerNamePosition);
LittleEndianUtilities.WriteUShort(stream, ServerNameLength);
LittleEndianUtilities.WriteUShort(stream, 0); // Extension unsupported
LittleEndianUtilities.WriteUShort(stream, 0); // Extension unsupported
LittleEndianUtilities.WriteUShort(stream, CltIntNamePosition);
LittleEndianUtilities.WriteUShort(stream, CltIntNameLength);
LittleEndianUtilities.WriteUShort(stream, LanguagePosition);
LittleEndianUtilities.WriteUShort(stream, LanguageLength);
LittleEndianUtilities.WriteUShort(stream, DatabasePosition);
LittleEndianUtilities.WriteUShort(stream, DatabaseLength);
stream.Write(ClientID, 0, 6);
LittleEndianUtilities.WriteUShort(stream, SSPIPosition);
LittleEndianUtilities.WriteUShort(stream, SSPILength);
LittleEndianUtilities.WriteUShort(stream, AtchDBFilePosition);
LittleEndianUtilities.WriteUShort(stream, AtchDBFileLength);
LittleEndianUtilities.WriteUShort(stream, ChangePasswordPosition);
LittleEndianUtilities.WriteUShort(stream, ChangePasswordLength);
LittleEndianUtilities.WriteUInt(stream, 0); // Long SSPI not supported
}
public void WriteUIntToMemoryStream()
{
var stream = new MemoryStream();
LittleEndianUtilities.WriteUInt(stream, 0x01234567);
CollectionAssert.AreEqual(new byte[] { 0x67, 0x45, 0x23, 0x01 }, stream.ToArray());
}
/// <summary>
/// Used to unpack IPackageable from a stream.
/// </summary>
/// <param name="stream">MemoryStream from which to unpack IPackageable.</param>
/// <returns>Returns true if successful.</returns>
public bool Unpack(MemoryStream stream)
{
stream.Read(this.TraceID, 0, 16);
stream.Read(this.ActivityID, 0, 16);
this.ActivitySequence = LittleEndianUtilities.ReadUInt(stream);
return(true);
}
/// <summary>
/// Skips a token within a stream based on token type
/// </summary>
/// <param name="tokenType">Type of the token to ignore</param>
/// <param name="stream">Stream that contains the token</param>
private static void IgnoreToken(TDSTokenType tokenType, MemoryStream stream)
{
switch (((byte)tokenType >> 4) & 0x3)
{
// Variable count token
case 0:
{
throw new NotSupportedException();
}
// Zero length token
case 1:
{
return;
}
// Variable length token
case 2:
{
if (tokenType == TDSTokenType.DataClassification)
{
throw new NotSupportedException();
}
ushort length = LittleEndianUtilities.ReadUShort(stream);
for (int i = 0; i < length; i++)
{
stream.ReadByte();
}
return;
}
// Fixed length token
case 3:
{
var bytesToRead = Math.Pow(2, ((byte)tokenType >> 2) & 0x3);
if (tokenType == TDSTokenType.Done || tokenType == TDSTokenType.DoneInProc || tokenType == TDSTokenType.DoneProc)
{
bytesToRead = 12; // Untill support is added
}
for (int i = 0; i < bytesToRead; i++)
{
stream.ReadByte();
}
return;
}
default:
{
throw new InvalidOperationException();
}
}
}
public void ReadUIntFromMemoryStream()
{
var stream = new MemoryStream();
stream.Write(new byte[] { 0x01, 0x23, 0x45, 0x67 });
stream.Seek(0, SeekOrigin.Begin);
var res = LittleEndianUtilities.ReadUInt(stream);
Assert.AreEqual((uint)0x67452301, res);
}
public void ReadUShortFromMemoryStream()
{
var stream = new MemoryStream();
stream.Write(new byte[] { 0x01, 0x23 });
stream.Seek(0, SeekOrigin.Begin);
var res = LittleEndianUtilities.ReadUShort(stream);
Assert.AreEqual(0x2301, res);
}
/// <summary>
/// Used to unpack IPackageable from a stream.
/// </summary>
/// <param name="stream">MemoryStream containing the object that needs to be unpacked.</param>
/// <returns>Returns true if successful.</returns>
public override bool Unpack(MemoryStream stream)
{
var length = LittleEndianUtilities.ReadUShort(stream);
this.Type = (TDSEnvChangeType)stream.ReadByte();
switch (this.Type)
{
case TDSEnvChangeType.Routing:
var routingDataValueLength = LittleEndianUtilities.ReadUShort(stream);
if (routingDataValueLength == 0 || stream.ReadByte() != 0)
{
throw new InvalidOperationException();
}
var protocolProperty = LittleEndianUtilities.ReadUShort(stream);
if (protocolProperty == 0)
{
throw new InvalidOperationException();
}
int strLength = LittleEndianUtilities.ReadUShort(stream) * 2;
var temp = new byte[strLength];
stream.Read(temp, 0, strLength);
this.Values["ProtocolProperty"] = string.Format("{0}", protocolProperty);
this.Values["AlternateServer"] = Encoding.Unicode.GetString(temp);
for (int i = 0; i < length - routingDataValueLength - sizeof(byte) - sizeof(ushort); i++)
{
// Ignore oldValue
stream.ReadByte();
}
break;
default:
{
for (int i = 0; i < length - sizeof(byte); i++)
{
// Ignore unsupported types
stream.ReadByte();
}
return(false);
}
}
return(true);
}
/// <summary>
/// Used to pack IPackageable to a stream.
/// </summary>
/// <param name="stream">MemoryStream in which IPackageable is packet into.</param>
public void Pack(MemoryStream stream)
{
LittleEndianUtilities.WriteUInt(stream, this.Length);
LittleEndianUtilities.WriteUInt(stream, this.TDSVersion);
LittleEndianUtilities.WriteUInt(stream, this.PacketSize);
LittleEndianUtilities.WriteUInt(stream, this.ClientProgVer);
LittleEndianUtilities.WriteUInt(stream, this.ClientPID);
LittleEndianUtilities.WriteUInt(stream, this.ConnectionID);
this.OptionFlags1.Pack(stream);
this.OptionFlags2.Pack(stream);
this.TypeFlags.Pack(stream);
this.OptionFlags3.Pack(stream);
LittleEndianUtilities.WriteUInt(stream, this.ClientTimeZone);
LittleEndianUtilities.WriteUInt(stream, this.ClientLCID);
TDSLogin7OptionFactory.WriteOptionsToStream(stream, this.Options, this.ClientID);
}
public void Pack(MemoryStream stream)
{
LittleEndianUtilities.WriteUInt(stream, Length);
LittleEndianUtilities.WriteUInt(stream, 1946157060); // 7.4 TDS Version
LittleEndianUtilities.WriteUInt(stream, 4096); // PacketSize
LittleEndianUtilities.WriteUInt(stream, 117440512); // ClientProgramVersion
LittleEndianUtilities.WriteUInt(stream, (uint)Process.GetCurrentProcess().Id); // Client Process ID
LittleEndianUtilities.WriteUInt(stream, 0); // Connection ID
OptionFlags1.Pack(stream);
OptionFlags2.Pack(stream);
TypeFlags.Pack(stream);
OptionFlags3.Pack(stream);
LittleEndianUtilities.WriteUInt(stream, 480); // Client time zone
LittleEndianUtilities.WriteUInt(stream, 1033); // Client LCID
OffsetLength.Pack(stream);
stream.Write(Data, 0, Data.Length);
// Extensions extensions not supported
}
public bool Unpack(MemoryStream stream)
{
LittleEndianUtilities.ReadUInt(stream);
TDSVersion = LittleEndianUtilities.ReadUInt(stream);
PacketSize = LittleEndianUtilities.ReadUInt(stream);
ClientProgVer = LittleEndianUtilities.ReadUInt(stream);
ClientPID = LittleEndianUtilities.ReadUInt(stream);
ConnectionID = LittleEndianUtilities.ReadUInt(stream);
OptionFlags1.Unpack(stream);
OptionFlags2.Unpack(stream);
TypeFlags.Unpack(stream);
OptionFlags3.Unpack(stream);
ClientTimeZone = Convert.ToInt32(LittleEndianUtilities.ReadUInt(stream));
ClientLCID = LittleEndianUtilities.ReadUInt(stream);
OffsetLength.Unpack(stream);
stream.Read(Data, 0, (int)OffsetLength.TotalLength());
// Extensions not supported
return(true);
}
/// <summary>
/// Writes TDS Login7 options to a stream
/// </summary>
/// <param name="stream">MemoryStream to write to</param>
/// <param name="options">Options to write to the stream</param>
/// <param name="clientID">ClientID to write to the stream</param>
public static void WriteOptionsToStream(MemoryStream stream, List <TDSLogin7Option> options, byte[] clientID)
{
ushort currentPos = 94;
foreach (var option in OptionOrder)
{
if (option != "ClientID")
{
LittleEndianUtilities.WriteUShort(stream, currentPos);
var tmp = options.Where(o => o.Name == option);
if (tmp.Any())
{
var opt = tmp.First();
LittleEndianUtilities.WriteUShort(stream, opt.Length);
opt.Position = currentPos;
currentPos += opt.TrueLength;
}
else
{
LittleEndianUtilities.WriteUShort(stream, 0);
}
}
else
{
stream.Write(clientID, 0, 6);
}
}
// Ignore LongSSPI, not supported
LittleEndianUtilities.WriteUInt(stream, 0);
options = options.OrderBy(opt => opt.Position).ToList();
foreach (var option in options)
{
option.Pack(stream);
}
}
/// <summary>
/// Used to unpack IPackageable from a stream.
/// </summary>
/// <param name="stream">MemoryStream from which to unpack IPackageable.</param>
/// <returns>Returns true if successful.</returns>
public bool Unpack(MemoryStream stream)
{
LittleEndianUtilities.ReadUInt(stream);
this.TDSVersion = LittleEndianUtilities.ReadUInt(stream);
this.PacketSize = LittleEndianUtilities.ReadUInt(stream);
this.ClientProgVer = LittleEndianUtilities.ReadUInt(stream);
this.ClientPID = LittleEndianUtilities.ReadUInt(stream);
this.ConnectionID = LittleEndianUtilities.ReadUInt(stream);
this.OptionFlags1.Unpack(stream);
this.OptionFlags2.Unpack(stream);
this.TypeFlags.Unpack(stream);
this.OptionFlags3.Unpack(stream);
this.ClientTimeZone = Convert.ToUInt32(LittleEndianUtilities.ReadUInt(stream));
this.ClientLCID = LittleEndianUtilities.ReadUInt(stream);
var result = TDSLogin7OptionFactory.ReadOptionsFromStream(stream);
this.ClientID = result.Item2;
this.Options = result.Item1;
return(true);
}
/// <summary>
/// Used to pack IPackageable to a stream.
/// </summary>
/// <param name="stream">MemoryStream in which IPackageable is packet into.</param>
public void Pack(MemoryStream stream)
{
stream.Write(this.TraceID, 0, this.TraceID.Length);
stream.Write(this.ActivityID, 0, this.ActivityID.Length);
LittleEndianUtilities.WriteUInt(stream, this.ActivitySequence);
}
/// <summary>
/// Reads TDS Login7 options from a stream
/// </summary>
/// <param name="stream">Stream containing the Login7 packet</param>
/// <returns>ClientID, TDS Login7 options pair</returns>
public static Tuple <List <TDSLogin7Option>, byte[]> ReadOptionsFromStream(MemoryStream stream)
{
var options = new List <TDSLogin7Option>();
var clientID = new byte[6];
foreach (var option in OptionOrder)
{
ushort position = 0;
ushort length = 0;
switch (option)
{
case "HostName":
case "UserName":
case "AppName":
case "ServerName":
case "CltIntName":
case "Language":
case "Database":
{
position = LittleEndianUtilities.ReadUShort(stream);
length = LittleEndianUtilities.ReadUShort(stream);
if (length != 0)
{
options.Add(new TDSLogin7TextOption(option, position, length));
}
break;
}
case "ClientID":
{
stream.Read(clientID, 0, 6);
break;
}
case "Password":
case "ChangePassword":
{
position = LittleEndianUtilities.ReadUShort(stream);
length = LittleEndianUtilities.ReadUShort(stream);
if (length != 0)
{
options.Add(new TDSLogin7PasswordOption(option, position, length));
}
break;
}
default:
{
position = LittleEndianUtilities.ReadUShort(stream);
length = LittleEndianUtilities.ReadUShort(stream);
if (length != 0)
{
throw new NotSupportedException();
}
break;
}
}
}
// Ignore LongSSPI, not supported
LittleEndianUtilities.ReadUInt(stream);
options = options.OrderBy(opt => opt.Position).ToList();
foreach (var option in options)
{
option.Unpack(stream);
}
return(new Tuple <List <TDSLogin7Option>, byte[]>(options, clientID));
}
