private void Process()
{
if (!BufSizeReady)
{
if (ClientMS.Length >= 4)
{
PacketSize = GetInteger() - 4;
if (PacketSize > 0 && PacketSize < 2000 * 1024) // small than 2M
{
PacketBuffer = new byte[PacketSize];
Console.WriteLine("/// Server Buffersize " + PacketSize.ToString() + " Bytes ///");
BufSizeReady = true;
}
}
}
else
{
if (ClientMS.Length == PacketSize)
{
ThreadPool.QueueUserWorkItem(MsgPack.Read, new object[] { ClientMS.ToArray(), this });
PacketBuffer = new byte[4];
ClientMS.Dispose();
ClientMS = new MemoryStream();
BufSizeReady = false;
}
}
}
/// <summary>
/// Write instruction operands into bytecode stream.
/// </summary>
/// <param name="writer">Bytecode writer.</param>
public override void WriteOperands(WordWriter writer)
{
Pipe.Write(writer);
NumPackets.Write(writer);
PacketSize.Write(writer);
PacketAlignment.Write(writer);
}
internal void SendNonReturn(string ClientMethodName, byte[] data)
{
try
{
lock (lockObject)
{
var packet = new SocketyPacket()
{
MethodName = ClientMethodName, PackData = data
};
var d = MessagePackSerializer.Serialize(packet);
if (serverSocket != null)
{
PacketSize size = PacketSize.Create(d.Length);
var sizeb = size.GetBytes();
commnicateStream.Write(sizeb, 0, sizeb.Length);
commnicateStream.Write(d, 0, d.Length);
}
}
}
catch (IOException ex)
{
//Logger.LogError($"SendNonReturn:{ex.ToString()}");
return;
}
catch (Exception ex)
{
throw ex;
}
}
private void SendHeartBeat()
{
try
{
lock (lockObject)
{
var packet = new SocketyPacket()
{
SocketyPacketType = SocketyPacket.SOCKETY_PAKCET_TYPE.HaertBeat
};
var d = MessagePackSerializer.Serialize(packet);
PacketSize size = PacketSize.Create(d.Length);
var sizeb = size.GetBytes();
commnicateStream.Write(sizeb, 0, sizeb.Length);
commnicateStream.Write(d, 0, d.Length);
}
}
catch (IOException ex)
{
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Write instruction operands into bytecode stream.
/// </summary>
/// <param name="writer">Bytecode writer.</param>
public override void WriteOperands(WordWriter writer)
{
Pipe.Write(writer);
ReserveId.Write(writer);
PacketSize.Write(writer);
PacketAlignment.Write(writer);
}
private async Task <MemoryStream> SendRequestImpl <TRequest>(TRequest request, TimeSpan?timeout)
where TRequest : IRequest
{
if (_disposed)
{
throw new ObjectDisposedException(nameof(LogicalConnection));
}
var requestId = _requestIdCounter.GetRequestId();
var responseTask = _responseReader.GetResponseTask(requestId);
var stream = CreateAndSerializeHeader(request, requestId);
MsgPackSerializer.Serialize(request, stream, _msgPackContext);
var totalLength = stream.Position - Constants.PacketSizeBufferSize;
var packetLength = new PacketSize((uint)(totalLength));
AddPacketSize(stream, packetLength);
ArraySegment <byte> buffer;
if (!stream.TryGetBuffer(out buffer))
{
throw new InvalidOperationException("broken buffer");
}
//keep API for the sake of backward comp.
_requestWriter.Write(
// merged header and body
buffer);
try
{
if (timeout.HasValue)
{
var cts = new CancellationTokenSource(timeout.Value);
responseTask = responseTask.WithCancellation(cts.Token);
}
var responseStream = await responseTask.ConfigureAwait(false);
_logWriter?.WriteLine($"Response with requestId {requestId} is recieved, length: {responseStream.Length}.");
return(responseStream);
}
catch (ArgumentException)
{
_logWriter?.WriteLine($"Response with requestId {requestId} failed, content:\n{buffer.ToReadableString()} ");
throw;
}
catch (TimeoutException)
{
PingsFailedByTimeoutCount++;
throw;
}
}
/// <summary>
/// Calculate number of words to fit complete instruction bytecode.
/// </summary>
/// <returns>Number of words in instruction bytecode.</returns>
public override uint GetWordCount()
{
uint wordCount = 0;
wordCount += Pipe.GetWordCount();
wordCount += ReserveId.GetWordCount();
wordCount += PacketSize.GetWordCount();
wordCount += PacketAlignment.GetWordCount();
return(wordCount);
}
/// <summary>
/// Calculate number of words to fit complete instruction bytecode.
/// </summary>
/// <returns>Number of words in instruction bytecode.</returns>
public override uint GetWordCount()
{
uint wordCount = 0;
wordCount += IdResultType.GetWordCount();
wordCount += IdResult.GetWordCount();
wordCount += PacketSize.GetWordCount();
wordCount += PacketAlignment.GetWordCount();
wordCount += Capacity.GetWordCount();
return(wordCount);
}
/// <summary>
/// Calculate number of words to fit complete instruction bytecode.
/// </summary>
/// <returns>Number of words in instruction bytecode.</returns>
public override uint GetWordCount()
{
uint wordCount = 0;
wordCount += IdResultType.GetWordCount();
wordCount += IdResult.GetWordCount();
wordCount += Pipe.GetWordCount();
wordCount += NumPackets.GetWordCount();
wordCount += PacketSize.GetWordCount();
wordCount += PacketAlignment.GetWordCount();
return wordCount;
}
/// <summary>
/// Calculate number of words to fit complete instruction bytecode.
/// </summary>
/// <returns>Number of words in instruction bytecode.</returns>
public override uint GetWordCount()
{
uint wordCount = 0;
wordCount += IdResultType.GetWordCount();
wordCount += IdResult.GetWordCount();
wordCount += Pipe.GetWordCount();
wordCount += ReserveId.GetWordCount();
wordCount += Index.GetWordCount();
wordCount += Pointer.GetWordCount();
wordCount += PacketSize.GetWordCount();
wordCount += PacketAlignment.GetWordCount();
return(wordCount);
}
private ArraySegment <byte> CreateAndSerializeHeader <TRequest>(
TRequest request,
RequestId requestId,
byte[] serializedRequest) where TRequest : IRequest
{
var packetSizeBuffer = new byte[Constants.PacketSizeBufferSize + Constants.MaxHeaderLength];
var stream = new MemoryStream(packetSizeBuffer);
var requestHeader = new RequestHeader(request.Code, requestId);
stream.Seek(Constants.PacketSizeBufferSize, SeekOrigin.Begin);
MsgPackSerializer.Serialize(requestHeader, stream, _msgPackContext);
var lengthAndHeaderLengthByteCount = (int)stream.Position;
var headerLength = lengthAndHeaderLengthByteCount - Constants.PacketSizeBufferSize;
var packetLength = new PacketSize((uint)(headerLength + serializedRequest.Length));
stream.Seek(0, SeekOrigin.Begin);
MsgPackSerializer.Serialize(packetLength, stream, _msgPackContext);
return(new ArraySegment <byte>(packetSizeBuffer, 0, lengthAndHeaderLengthByteCount));
}
public USBDeviceCore(IUSBDevice device,
USBClassCode classCode = USBClassCode.NotSpecified,
byte subClassCode = 0,
byte protocol = 0,
USBProtocol usbProtocolVersion = USBProtocol.USB_2_0,
short deviceReleaseNumber = 0,
PacketSize maximalPacketSize = PacketSize.Size64,
string manufacturerName = null,
string productName = null,
string serialNumber = null,
ushort vendorId = 0,
ushort productId = 0,
Action <SetupPacket, byte[], Action <byte[]> > customSetupPacketHandler = null) : base(18, (byte)DescriptorType.Device)
{
if (maximalPacketSize != PacketSize.Size8 &&
maximalPacketSize != PacketSize.Size16 &&
maximalPacketSize != PacketSize.Size32 &&
maximalPacketSize != PacketSize.Size64)
{
throw new ConstructionException("Unsupported maximal packet size.");
}
this.customSetupPacketHandler = customSetupPacketHandler;
this.device = device;
configurations = new List <USBConfiguration>();
CompatibleProtocolVersion = usbProtocolVersion;
Class = classCode;
SubClass = subClassCode;
Protocol = protocol;
DeviceReleaseNumber = deviceReleaseNumber;
MaximalPacketSize = maximalPacketSize;
ManufacturerName = manufacturerName;
ProductName = productName;
SerialNumber = serialNumber;
VendorId = vendorId;
ProductId = productId;
RegisterSubdescriptors(configurations);
}
/// <summary>
/// 受信を一括して行う
/// </summary>
private void ReceiveProcess()
{
byte[] sizeb = new byte[sizeof(int)];
Logger.LogInformation("ReceiveProcess Start");
while (_stoppingCts.IsCancellationRequested == false)
{
try
{
if (serverSocket == null)
{
TcpReceiveThreadFinishEvent.Set();
return;
}
int bytesRec = commnicateStream.Read(sizeb, 0, sizeof(int));
lock (lockObject)
{
if (bytesRec > 0)
{
int size = BitConverter.ToInt32(sizeb, 0);
byte[] buffer = new byte[size];
int DataSize = 0;
do
{
bytesRec = commnicateStream.Read(buffer, DataSize, size - DataSize);
DataSize += bytesRec;
} while (size > DataSize);
var packet = MessagePackSerializer.Deserialize <SocketyPacket>(buffer);
//AuthentificationFilter
bool AuthentificationSuccess = true;
var authentificationFilter = SocketyFilters.Get <IAuthenticationFIlter>();
var method = GetMethod(packet);
if (packet.SocketyPacketType == SocketyPacket.SOCKETY_PAKCET_TYPE.Data && authentificationFilter != null)
{
bool FindIgnore = false;
if (method.GetCustomAttribute <SocketyAuthentificationIgnoreAttribute>() != null)
{
//SocketyAuthentificationIgnoreがあるメソッドは認証を行わない
FindIgnore = true;
AuthentificationSuccess = true;
}
if (FindIgnore == false)
{
AuthentificationSuccess = authentificationFilter.Authentication(packet.Toekn);
}
}
if (AuthentificationSuccess == true)
{
if (packet.SocketyPacketType == SocketyPacket.SOCKETY_PAKCET_TYPE.HaertBeat)
{
ReceiveHeartBeat();
}
else
{
//メソッドの戻り値を詰め替える
packet.PackData = InvokeMethod(method, packet);
//InvokeMethodAsyncの戻り値を送り返す
var d = MessagePackSerializer.Serialize(packet);
PacketSize packetSize = PacketSize.Create(d.Length);
var sizeb2 = packetSize.GetBytes();
commnicateStream.Write(sizeb2, 0, sizeb2.Length);
commnicateStream.Write(d, 0, d.Length);
}
}
else
{
Logger.LogInformation($"Client Authentificateion Fail \r\n{packet.clientInfo.ToString()}");
//認証失敗は接続を切断
DisConnect();
}
}
}
}
catch (IOException ex)
{
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
}
Thread.Sleep(10);
}
}
public override bool Connect(TdsConnectionParameters connectionParameters)
{
if (IsConnected)
{
throw new InvalidOperationException("The connection is already open.");
}
SetCharset(connectionParameters.Charset);
SetLanguage(connectionParameters.Language);
byte pad = (byte)0;
byte[] empty = new byte[0];
Comm.StartPacket(TdsPacketType.Logon);
// hostname (offset 0)
byte[] tmp = Comm.Append(connectionParameters.Hostname, 30, pad);
Comm.Append((byte)(tmp.Length < 30 ? tmp.Length : 30));
// username (offset 31 0x1f)
tmp = Comm.Append(connectionParameters.User, 30, pad);
Comm.Append((byte)(tmp.Length < 30 ? tmp.Length : 30));
// password (offset 62 0x3e)
tmp = Comm.Append(GetPlainPassword(connectionParameters.Password), 30, pad);
Comm.Append((byte)(tmp.Length < 30 ? tmp.Length : 30));
// hostproc (offset 93 0x5d)
Comm.Append("00000116", 8, pad);
// unused (offset 109 0x6d)
Comm.Append(empty, (30 - 14), pad);
// apptype
Comm.Append((byte)0x0);
Comm.Append((byte)0xa0);
Comm.Append((byte)0x24);
Comm.Append((byte)0xcc);
Comm.Append((byte)0x50);
Comm.Append((byte)0x12);
// hostproc length
Comm.Append((byte)8);
// Byte order of 2 byte ints
// 2 = <MSB, LSB>, 3 = <LSB, MSB>
Comm.Append((byte)3);
// Byte order of 4 byte ints
// 0 = <MSB, LSB>, 1 = <LSB, MSB>
Comm.Append((byte)1);
// Character representation
// (6 = ASCII, 7 = EBCDIC)
Comm.Append((byte)6);
// Eight byte floating point representation
// 4 = IEEE <MSB, ..., LSB>
// 5 = VAX 'D'
// 10 = IEEE <LSB, ..., MSB>
// 11 = ND5000
Comm.Append((byte)10);
// Eight byte date format
// 8 = <MSB, ..., LSB>
Comm.Append((byte)9);
// notify of use db
Comm.Append((byte)1);
// disallow dump/load and bulk insert
Comm.Append((byte)1);
// sql interface type
Comm.Append((byte)0);
// type of network connection
Comm.Append((byte)0);
// spare [7]
Comm.Append(empty, 7, pad);
// appname
tmp = Comm.Append(connectionParameters.ApplicationName, 30, pad);
Comm.Append((byte)(tmp.Length < 30 ? tmp.Length : 30));
// server name
tmp = Comm.Append(DataSource, 30, pad);
Comm.Append((byte)(tmp.Length < 30 ? tmp.Length : 30));
// remote passwords
Comm.Append(empty, 2, pad);
tmp = Comm.Append(GetPlainPassword(connectionParameters.Password), 253, pad);
Comm.Append((byte)(tmp.Length < 253 ? tmp.Length + 2 : 253 + 2));
// tds version
Comm.Append((byte)(((byte)Version) / 10));
Comm.Append((byte)(((byte)Version) % 10));
Comm.Append((byte)0);
Comm.Append((byte)0);
// prog name
tmp = Comm.Append(connectionParameters.ProgName, 10, pad);
Comm.Append((byte)(tmp.Length < 10 ? tmp.Length : 10));
// prog version
Comm.Append((byte)6);
// Tell the server we can handle SQLServer version 6
Comm.Append((byte)0);
// Send zero to tell the server we can't handle any other version
Comm.Append((byte)0);
Comm.Append((byte)0);
// auto convert short
Comm.Append((byte)0);
// type of flt4
Comm.Append((byte)0x0d);
// type of date4
Comm.Append((byte)0x11);
// language
tmp = Comm.Append(Language, 30, pad);
Comm.Append((byte)(tmp.Length < 30 ? tmp.Length : 30));
// notify on lang change
Comm.Append((byte)1);
// security label hierarchy
Comm.Append((short)0);
// security components
Comm.Append(empty, 8, pad);
// security spare
Comm.Append((short)0);
// security login role
Comm.Append((byte)0);
// charset
tmp = Comm.Append(Charset, 30, pad);
Comm.Append((byte)(tmp.Length < 30 ? tmp.Length : 30));
// notify on charset change
Comm.Append((byte)1);
// length of tds packets
tmp = Comm.Append(PacketSize.ToString(), 6, pad);
Comm.Append((byte)3);
// pad out to a longword
Comm.Append(empty, 8, pad);
Comm.SendPacket();
MoreResults = true;
SkipToEnd();
return(IsConnected);
}
public void Write(Stream stream, DbEnvironment env)
{
Logger.Instance?.WriteLine($"Write {Type}");
stream.WritePaddedString(Hostname, TDS_MAXNAME, env.Encoding); //lhostname
stream.WritePaddedString(Username, TDS_MAXNAME, env.Encoding); //lussername
stream.WritePaddedString(EncryptPassword ? string.Empty : Password, TDS_MAXNAME, env.Encoding);
stream.WritePaddedString(ProcessId, TDS_MAXNAME, env.Encoding); //lhostproc
stream.Write(new byte[]
{
(byte)LInt2,
(byte)LInt4,
(byte)LChar,
(byte)LFlt,
(byte)LDt,
(byte)LUseDb.TRUE, //lusedb
(byte)LDmpLd.FALSE, //ldmpld
(byte)LInterfaceSpare,
(byte)LType,
0, 0, 0, 0, //lbufsize
0, 0, 0, //lspare
});
stream.WritePaddedString(ApplicationName, TDS_MAXNAME, env.Encoding); //lappname
stream.WritePaddedString(ServerName, TDS_MAXNAME, env.Encoding); //lservname
//spec's a bit weird when it comes to this bit... following ADO.net driver
//lrempw, lrempwlen
stream.WriteWeirdPasswordString(EncryptPassword ? string.Empty : Password, TDS_RPLEN, env.Encoding);
//ltds version
stream.Write(new byte[] { 5, 0, 0, 0 });
stream.WritePaddedString(ClientLibrary, TDS_PROGNLEN, env.Encoding);
stream.Write(new byte[] { 0x0f, 0x07, 0x00, 0x0d }); //lprogvers //doesn't matter what this value is really
stream.Write(new[]
{
(byte)LNoShort,
(byte)LFlt4,
(byte)LDate4
});
stream.WritePaddedString(Language, TDS_MAXNAME, env.Encoding); //llanguage
var lSecLogin = EncryptPassword
? LSecLogin.TDS_SEC_LOG_ENCRYPT3
: LSecLogin.UNUSED;
stream.Write(new byte[]
{
(byte)LSetLang,
0, 0, //loldsecure
(byte)lSecLogin,
0, 8, 0, 0, 0, 0, 0, 0, 0, 0 //lsecbulk, lhalogin, lhasessionid, lsecspare
});
stream.WritePaddedString(Charset, TDS_MAXNAME, env.Encoding); //lcharset
stream.WriteByte((byte)LSetCharset); //lsetcharset
stream.WritePaddedString(PacketSize.ToString(), TDS_PKTLEN, env.Encoding); //lpacketsize
//ldummy
stream.Write(new byte[]
{
//0xDE, 0xAD, 0xBE, 0xEF
0x00, 0x00, 0x00, 0x00
});
Capability.Write(stream, env);
}
private bool SaveAdvancedOptions()
{
// Validate input.
var regex = new Regex("^\\d+$");
// Validate TTL.
if (!regex.IsMatch(TTL.Text) || int.Parse(TTL.Text) < 1 || int.Parse(TTL.Text) > 255)
{
AdvancedTab.Focus();
MessageBox.Show(
"Please enter a valid TTL between 1 and 255.",
"vmPing Error",
MessageBoxButton.OK,
MessageBoxImage.Error);
TTL.Focus();
return(false);
}
// Apply TTL.
ApplicationOptions.TTL = int.Parse(TTL.Text);
// Validate packet size.
if (PacketSizeOption.IsChecked == true)
{
if (!regex.IsMatch(PacketSize.Text) || int.Parse(PacketSize.Text) < 0 || int.Parse(PacketSize.Text) > 65500)
{
AdvancedTab.Focus();
MessageBox.Show(
"Please enter a valid ICMP data size between 0 and 65,500.",
"vmPing Error",
MessageBoxButton.OK,
MessageBoxImage.Error);
PacketSize.Focus();
return(false);
}
// Apply packet size.
ApplicationOptions.Buffer = new byte[int.Parse(PacketSize.Text)];
ApplicationOptions.UseCustomBuffer = false;
// Fill buffer with default text.
if (ApplicationOptions.Buffer.Length >= 33)
{
Buffer.BlockCopy(Encoding.ASCII.GetBytes(Constants.PING_DATA), 0, ApplicationOptions.Buffer, 0, 33);
}
}
else
{
// Use custom packet data.
ApplicationOptions.Buffer = Encoding.ASCII.GetBytes(PacketData.Text);
ApplicationOptions.UseCustomBuffer = true;
}
// Apply fragment / don't fragment option.
if (DontFragment.IsChecked == true)
{
ApplicationOptions.DontFragment = true;
}
else
{
ApplicationOptions.DontFragment = false;
}
// Update ping options (TTL / Don't fragment settings)
ApplicationOptions.UpdatePingOptions();
return(true);
}
/// <summary>
/// TCP受信用スレッド
/// </summary>
private void ReceiveProcess()
{
byte[] sizeb = new byte[8];
while (true)
{
if (ThreadCancellationToken.Token.IsCancellationRequested)
{
System.Diagnostics.Debug.WriteLine("ReceiveProcess Kill");
TcpReceiveThreadFinishEvent.Set();
return;
}
try
{
//データサイズ受信
int bytesRec = stream.Read(sizeb, 0, sizeb.Length);
var packetSize = PacketSize.FromBytes(sizeb);
if (packetSize != null && packetSize.Size < SocketySetting.MAX_BUFFER)
{
//データ領域確保
var buffer = new byte[packetSize.Size];
int DataSize = 0;
do
{
if (ThreadCancellationToken.Token.IsCancellationRequested == true)
{
System.Diagnostics.Debug.WriteLine("ReceiveProcess Kill2");
TcpReceiveThreadFinishEvent.Set();
return;
}
if (serverSocket.Connected == false || Connected == false)
{
System.Diagnostics.Debug.WriteLine("Break");
TcpReceiveThreadFinishEvent.Set();
return;
}
else
{
//データ受信
bytesRec = stream.Read(buffer, DataSize, packetSize.Size - DataSize);
DataSize += bytesRec;
}
} while (packetSize.Size > DataSize);
if (bytesRec > 0)
{
SocketyPacket packet = null;
try
{
packet = MessagePackSerializer.Deserialize <SocketyPacket>(buffer);
}
catch
{
System.Diagnostics.Debug.WriteLine("MessagePack Fail");
packet = null;
}
if (packet != null)
{
lock (RecieveSyncEvent)
{
if (packet.SocketyPacketType == SocketyPacket.SOCKETY_PAKCET_TYPE.HaertBeat)
{
ReceiveHeartBeat();
}
else
{
if (string.IsNullOrEmpty(ServerCallMethodName) != true && ServerCallMethodName == packet.MethodName)
{
///サーバのレスポンスを待つタイプの場合は待ちイベントをセットする
ServerResponse = packet.PackData;
RecieveSyncEvent.Set();
}
else
{
///非同期なので、クライアントメソッドを呼ぶ
InvokeMethod(packet);
}
}
}
}
}
else
{
Thread.Sleep(100);
}
}
else
{
Logger.LogError("PacketSize Error");
}
}
catch (IOException ex)
{
Logger.LogInformation(ex.ToString());
}
catch (Exception ex)
{
Logger.LogInformation(ex.ToString());
}
Thread.Sleep(10);
}
}
/// <summary>
/// Write instruction operands into bytecode stream.
/// </summary>
/// <param name="writer">Bytecode writer.</param>
public override void WriteOperands(WordWriter writer)
{
PacketSize.Write(writer);
PacketAlignment.Write(writer);
Capacity.Write(writer);
}
private void AddPacketSize(MemoryStream stream, PacketSize packetLength)
{
stream.Seek(0, SeekOrigin.Begin);
MsgPackSerializer.Serialize(packetLength, stream, _msgPackContext);
}
public void SendLogin()
{
StartRequest();
_logger?.LogDebug("Sending login message");
_req.SetPacketType(PacketType.TDS_BUF_LOGIN);
_req.WriteLoginString(_paramaters.ClientHostname, 30); // client hostname
_req.WriteLoginString(_paramaters.Username, 30); // client username
_req.WriteLoginString(_paramaters.Password, 30); // client password
_req.WriteLoginString(_paramaters.ProcessId, 30); // client process name
_req.Write((byte)3); // type of int2
_req.Write((byte)1); // type of int4
_req.Write((byte)6); // type of char
_req.Write((byte)10); // type of flt
_req.Write((byte)9); // type of date
_req.Write((byte)1); // notify of use db
_req.Write((byte)1); // disallow dump/load and bulk insert
_req.Write((byte)0); // sql interface type
_req.Write((byte)0); // type of network connection
_req.Write(null, 0, 7);
_req.WriteLoginString(_paramaters.AppliactionName, 30); // client application name
_req.WriteLoginString(_paramaters.ServerName, 30); // server name
_req.Write((byte)0); // remote passwords
_req.Write((byte)_paramaters.Password.Length);
byte[] tmpPassword = Encoder.GetBytes(_paramaters.Password);
_req.Write(tmpPassword, 0, 253);
_req.Write((byte)(tmpPassword.Length + 2));
_req.Write((byte)5); // tds version
_req.Write((byte)0);
_req.Write((byte)0);
_req.Write((byte)0);
_req.WriteLoginString("TdsClient", 10); // client library
_req.Write((byte)5); // prog version
_req.Write((byte)0);
_req.Write((byte)0);
_req.Write((byte)0);
_req.Write((byte)0); // auto convert short
_req.Write((byte)0x0D); // type of flt4
_req.Write((byte)0x11); // type of date4
_req.WriteLoginString(_paramaters.Language, 30); // language
_req.Write((byte)1); // notify on lang change
_req.Write((byte)0); // security label hierachy 1
_req.Write((byte)0); // security label hierachy 2
_req.Write((byte)0); // security encrypted
_req.Write(null, 0, 8); // security components
_req.Write((byte)0); // security spare 1
_req.Write((byte)0); // security spare 2
_req.WriteLoginString(_paramaters.Charset, 30); // Character set
_req.Write((byte)1); // notify on charset change
_req.WriteLoginString(PacketSize.ToString(), 6);
_req.Write(null, 0, 4);
// send capability token?
_req.EndMessage();
}
