private void TelnetDisplayStartup(
ServerConnectPack ConnectPack, NegotiateSettings NegotiateSettings,
ConcurrentMessageQueue TelnetQueue,
FromThread FromThread, ToThread ToThread,
Window ClientWindow, Action <bool, TypeTelnetDevice?> TelnetStartupComplete)
{
// initial telnet back and forth negotiation with server.
var rv = TelnetConnection.TelnetConnectAndNegotiate(
ConnectPack.HostName, NegotiateSettings,
TelnetQueue, ToThread);
var sessionSettings = rv.Item1;
ConnectPack.Settings = sessionSettings;
// read the dataStreamHeader from the Telnet thread.
// this message contains the startup up code ( I902 ), system name and
// printer name. The next message from the server will be sent when there
// is a spooled file ready to print.
var attrMsg = TelnetQueue.WaitAndDequeue() as TelnetDeviceAttrMessage;
if (attrMsg != null)
{
// signal startup is complete to the telnet window on the UI thread.
var bi = ClientWindow.Dispatcher.BeginInvoke(
DispatcherPriority.Input, new ThreadStart(
() =>
{
TelnetStartupComplete(true, attrMsg.TypeDevice);
}));
}
}
public ToThread(
ExtendedManualResetEvent ShutdownFlag, TcpClient Client,
ScreenDim ScreenDim)
: base(ShutdownFlag)
{
this.Client = Client;
this.InputQueue = new ConcurrentMessageQueue();
this.ConnectionFailedEvent = new AutoResetEvent(false);
this.LogList = new TelnetLogList("To");
}
public TestQueue(ISubscriber bus = null)
{
Messages = new ConcurrentMessageQueue <Message>("Messages");
_messageSet = new HashSet <Message>();
Commands = new ConcurrentMessageQueue <Command>("Commands");
Responses = new ConcurrentMessageQueue <CommandResponse>("Responses");
Events = new ConcurrentMessageQueue <DomainEvent>("Events");
_waitQueue = new ConcurrentMessageQueue <Message>("Wait Queue");
bus?.Subscribe(this);
}
public TelnetStartupMessage(
ConcurrentMessageQueue TelnetQueue,
ServerConnectPack ServerConnectPack, NegotiateSettings NegotiateSettings,
Window ClientWindow, Action <bool, TypeTelnetDevice?> TelnetStartupComplete,
TypeTelnetDevice TypeTelnetDevice)
{
this.TelnetQueue = TelnetQueue;
this.ServerConnectPack = ServerConnectPack;
this.NegotiateSettings = NegotiateSettings;
this.ClientWindow = ClientWindow;
this.TypeTelnetDevice = TypeTelnetDevice;
this.TelnetStartupComplete = TelnetStartupComplete;
}
public void Reset()
{
if (!running)
{
INqueue = new ConcurrentMessageQueue();
OUTqueue = new Dictionary <Sesion, ConcurrentMessageQueue>();
sesions = new List <Sesion>();
}
else
{
throw new InvalidOperationException("Server is running");
}
}
public FromThread(
ExtendedManualResetEvent ShutdownFlag, TcpClient Client,
ConcurrentMessageQueue TelnetQueue,
SessionSettings Settings, ScreenDim ScreenDim)
: base(ShutdownFlag)
{
this.Client = Client;
this.InputQueue = new ConcurrentMessageQueue();
this.TelnetQueue = TelnetQueue;
this.ConnectionFailedEvent = new ExtendedManualResetEvent(false);
this.SessionSettings = Settings;
this.LogList = new TelnetLogList("From");
}
/*
* while (client.Connected && running)
* {
* int toRead = client.Available;
* if (toRead > 0)
* {
* sesion.LastSeen = DateTime.Now.Ticks;
* sesion.Notified = false;
* buffer[bufPos++] = (byte)stream.ReadByte();
* if (buffer[bufPos - 1] == '\n')
* {
* string recString = Encoding.ASCII.GetString(buffer, 0, bufPos - 1);
* bufPos = 0;
* recString = recString.Trim();
*
* Log.WriteLine(sesion.Address + ">" + recString);
*
* if (recString.StartsWith(CoreUtil.MUVC_STRING))
* {
* if (recString == CoreUtil.DISCONNECT_STRING)
* {
* client.Close();
* lock (OUTqueue)
* {
* OUTqueue.Remove(sesion);
* }
* lock (sesions)
* {
* sesions.Remove(sesion);
* }
*
* Log.WriteLine("Client DSC:" + sesion.Address);
*
* return;
* }
* else
* {
* //handle MUVC commands
* }
* }
* else
* {
* if (MessageRecieved == null || eventpush)
* {
* INqueue.Enqueue(new Message(recString, sesion));
* }
* MessageRecieved?.Invoke(recString, sesion);
*
* }
* }
* }
* if (!OUTQ.IsEmpty())
* {
* string trString = OUTQ.Dequeue().Contents;
* byte[] sendbuf = Encoding.ASCII.GetBytes(trString + "\n");
* stream.Write(sendbuf, 0, sendbuf.Length);
* if (trString == CoreUtil.DISCONNECT_STRING)
* {
* client.Close();
* lock (OUTqueue)
* {
* OUTqueue.Remove(sesion);
* }
* lock (sesions)
* {
* sesions.Remove(sesion);
* }
*
* Log.WriteLine("Client Terminated:" + sesion.Address);
*
* return;
* }
*
* Log.WriteLine(sesion.Address + "<" + trString);
* }
* if (TimeToLiveSeconds >= 0 && (DateTime.Now.Ticks - sesion.LastSeen) / CoreUtil.TICKS_PER_SECOND > TimeToLiveSeconds)
* {
* if (sesion.Notified)
* {
* client.Close();
* lock (OUTqueue)
* {
* OUTqueue.Remove(sesion);
* }
* lock (sesions)
* {
* sesions.Remove(sesion);
* }
*
* Log.WriteLine("Client Timed Out:" + sesion.Address);
*
* return;
* }
* else
* {
* byte[] Ksendbuf = Encoding.ASCII.GetBytes(CoreUtil.KEEPALIVE_STRING + "\n");
* stream.Write(Ksendbuf, 0, Ksendbuf.Length);
* sesion.LastSeen = DateTime.Now.Ticks;
* sesion.Notified = true;
*
* Log.WriteLine("Client Notified:" + sesion.Address);
* }
* }
*
* }
* byte[] Dsendbuf = Encoding.ASCII.GetBytes(CoreUtil.DISCONNECT_STRING + "\n");
* stream.Write(Dsendbuf, 0, Dsendbuf.Length);
* client.Close();
* lock (OUTqueue)
* {
* OUTqueue.Remove(sesion);
* }
* lock (sesions)
* {
* sesions.Remove(sesion);
* }
*/
private void ClientThread(object data)
{
TcpClient client = (TcpClient)data;
Sesion sesion = new Sesion((IPEndPoint)client.Client.RemoteEndPoint);
ConcurrentMessageQueue OUTQ = new ConcurrentMessageQueue();
Random random = new Random();
lock (sesion)
{
sesions.Add(sesion);
}
lock (OUTqueue)
{
OUTqueue[sesion] = OUTQ;
}
NetworkStream stream = client.GetStream();
byte[] buffer = new byte[_BufferSize];
byte[] sendbuf;
string msg;
int bufPos = 0;
sesion.LastSeen = DateTime.Now.Ticks;
double cTTL = _TimeToLiveSeconds * (random.NextDouble() + 1);
//sesion.Notified = false;
Log.WriteLine("Client Opened:" + sesion.Address);
while (client.Connected && running)
{
if (client.Available > 0)
{
buffer[bufPos++] = (byte)stream.ReadByte();
if (buffer[bufPos - 1] == CoreUtil.MESSAGE_TERMINATOR)
{
sesion.LastSeen = DateTime.Now.Ticks;
cTTL = _TimeToLiveSeconds * (random.NextDouble() + 1);
//sesion.Notified = false;
msg = Encoding.ASCII.GetString(buffer, 0, bufPos - 1);
bufPos = 0;
Log.WriteLine(sesion.Address + ">" + msg);
if (msg.StartsWith(CoreUtil.MUVC_STRING))
{
if (msg == CoreUtil.DISCONNECT_STRING)
{
client.Close();
lock (OUTqueue)
{
OUTqueue.Remove(sesion);
}
lock (sesions)
{
sesions.Remove(sesion);
}
Log.WriteLine("Client DSC:" + sesion.Address);
return;
}
//else if (msg == CoreUtil.KEEPALIVE_STRING)
//{
// sendbuf = Encoding.ASCII.GetBytes(CoreUtil.ACKNOWLEDGE_STRING + CoreUtil.MESSAGE_TERMINATOR);
// safeWrite(stream, sendbuf, 0, sendbuf.Length);
// Log.WriteLine("Responded to client keepalive:" + sesion.Address);
//}
else
{
//TODO handle other MUVC commands
}
}
else
{
recMessage handler = MessageRecieved;
if (handler == null || _EventPush)
{
INqueue.Enqueue(new Message(msg, sesion));
}
handler?.Invoke(msg, sesion);
}
}
}
if (!OUTQ.IsEmpty())
{
msg = OUTQ.Dequeue().Contents;
sendbuf = Encoding.ASCII.GetBytes(msg + CoreUtil.MESSAGE_TERMINATOR);
SafeWrite(stream, sendbuf, 0, sendbuf.Length);
sesion.LastSeen = DateTime.Now.Ticks;
cTTL = _TimeToLiveSeconds * (random.NextDouble() + 1);
if (msg == CoreUtil.DISCONNECT_STRING)
{
client.Close();
lock (OUTqueue)
{
OUTqueue.Remove(sesion);
}
lock (sesions)
{
sesions.Remove(sesion);
}
Log.WriteLine("Client Terminated:" + sesion.Address);
return;
}
Log.WriteLine(sesion.Address + "<" + msg);
}
if (_TimeToLiveSeconds >= 0 && (DateTime.Now.Ticks - sesion.LastSeen) / CoreUtil.TICKS_PER_SECOND > cTTL)
{
//if (sesion.Notified)
//{
// client.Close();
// lock (OUTqueue)
// {
// OUTqueue.Remove(sesion);
// }
// lock (sesions)
// {
// sesions.Remove(sesion);
// }
// Log.WriteLine("Client Timed Out:" + sesion.Address);
// return;
//}
//else
//{
sendbuf = Encoding.ASCII.GetBytes(CoreUtil.KEEPALIVE_STRING + CoreUtil.MESSAGE_TERMINATOR);
SafeWrite(stream, sendbuf, 0, sendbuf.Length);
sesion.LastSeen = DateTime.Now.Ticks;
cTTL = _TimeToLiveSeconds * (random.NextDouble() + 1);
//sesion.Notified = true;
Log.WriteLine("Client Notified:" + sesion.Address);
//}
}
}
sendbuf = Encoding.ASCII.GetBytes(CoreUtil.DISCONNECT_STRING + CoreUtil.MESSAGE_TERMINATOR);
SafeWrite(stream, sendbuf, 0, sendbuf.Length);
client.Close();
lock (OUTqueue)
{
OUTqueue.Remove(sesion);
}
lock (sesions)
{
sesions.Remove(sesion);
}
Log.WriteLine("Client Closed:" + sesion.Address);
}
