public void EntryPoint()
{
this.ThreadEndedEvent.Reset();
try
{
// loop receiving from the server until:
// - the foreground thread wants to shutdown the connection. It has set
// the ShutdownFlag event.
while ((ShutdownFlag.State == false))
{
var message = InputQueue.WaitAndDequeue(this.ShutdownFlag.EventObject);
if (message != null)
{
if (message is CaptureContentMessage)
{
var captureMessage = message as CaptureContentMessage;
DoCapture(captureMessage.ScreenDefn, captureMessage.ScreenContent,
captureMessage.CaptureFolderPath);
}
if (message is GeneralThreadMessage)
{
var generalMessage = message as GeneralThreadMessage;
var screenContent = generalMessage.ScreenContent;
}
}
}
}
finally
{
// in case anyone waiting for this thread to end. Signal the ended event.
ThreadEndedEvent.Set();
}
}
public void EntryPoint()
{
this.ThreadEndedEvent.Reset();
try
{
// loop receiving from the server until:
// - the foreground thread wants to shutdown the connection. It has set
// the ShutdownFlag event.
while ((ShutdownFlag.State == false))
{
var message = InputQueue.WaitAndDequeue(this.ShutdownFlag.EventObject);
if (message != null)
{
// startup message sent by MainWindow after the threads have been
// started. Once startup is completed ( telnet negotiation ) the
// startup completed event is signaled back on the MainWindow.
if (message is TelnetStartupMessage)
{
var startupMessage = message as TelnetStartupMessage;
if (startupMessage.TypeTelnetDevice == TypeTelnetDevice.Terminal)
{
TelnetDisplayStartup(
startupMessage.ServerConnectPack,
startupMessage.NegotiateSettings,
startupMessage.TelnetQueue,
FromThread, ToThread,
startupMessage.ClientWindow,
startupMessage.TelnetStartupComplete);
}
else if (startupMessage.TypeTelnetDevice == TypeTelnetDevice.Printer)
{
TelnetPrinterStartup(
startupMessage.ServerConnectPack,
startupMessage.NegotiateSettings,
startupMessage.TelnetQueue,
FromThread, ToThread,
startupMessage.ClientWindow,
startupMessage.TelnetStartupComplete);
}
}
else if (message is GeneralThreadMessage)
{
var generalMessage = message as GeneralThreadMessage;
switch (generalMessage.MessageCode)
{
}
}
}
}
}
finally
{
// in case anyone waiting for this thread to end. Signal the ended event.
ThreadEndedEvent.Set();
}
}
public virtual void EntryPoint()
{
try
{
using (this)
{
using (ReadBuffer readBuf = new ReadBuffer())
{
// store the readBuf as a property so the ThreadSupervisor has access.
ReadBuffer = readBuf;
Supervisor.AssignCurrentReadBuffer(ReadBuffer);
Supervisor.AssureReceiveThread(Conn, mRunLog);
// run the actual command on the telnet server.
string[] respLines = null;
if (CommandMethod != null)
{
respLines = CommandMethod(this, ReadBuffer, WriteEventLog, CommandText);
}
else
{
respLines = this.CommandRoute.RunCommand(
this, ReadBuffer, WriteEventLog, CommandText);
}
this.RunLog.Write(respLines);
RunLog.Write(respLines);
}
RunLog.Write("Exit.");
}
}
finally
{
// call the thread ended callback method.
if (ThreadEndedCallback != null)
{
ThreadEndedCallback();
}
// in case anyone waiting for this thread to end. Signal the ended event.
ThreadEndedEvent.Set();
}
}
// The ReceiveThread is relatively simple.
// It continuously reads from the socket connected to the telnet server. Whatever
// is received is appended to a Read buffer and an event is signaled to alert
// CommandThreads to come and get the data. The CommandThread which gets the data
// then empties the ReadBuffer and waits again on the "DataArrived" event to be
// signaled by this thread.
public void EntryPoint()
{
try
{
mRunLog.Write("Start reading from telnet server");
while (mShutdownFlag.State == false)
{
if (mConn.IsConnected == false)
{
break;
}
string s1 = mConn.Read();
// append what was just read to the ReadBuffer.
lock (mSupervisor.LockFlag)
{
if (mSupervisor.CurrentReadBuffer != null)
{
mSupervisor.CurrentReadBuffer.Buffer.Append(s1);
}
// Signal command threads that there is read data available. ( The command
// thread then resets the event after it checks/removes from the data buffer. )
mSupervisor.CurrentReadBuffer.GotDataEvent.Set();
}
}
mRunLog.Write("Exit.");
}
finally
{
// in case anyone waiting for this thread to end. Signal the ended event.
ThreadEndedEvent.Set();
}
}
public void EntryPoint()
{
this.ThreadEndedEvent.Reset();
try
{
// loop receiving from the server until:
// - the foreground thread wants to shutdown the connection. It has set
// the ShutdownFlag event.
while ((ShutdownFlag.State == false))
{
var message = InputQueue.WaitAndDequeue(this.ShutdownFlag.EventObject);
if (message != null)
{
if (message is AidKeyResponseMessage)
{
var msg = message as AidKeyResponseMessage;
var content = msg.ScreenContent.GetWorkingContentBlock();
BuildAndSendResponseDataStream(msg.AidKey, content, this.LogList);
}
else if (message is SaveScreenMessage)
{
var msg = message as SaveScreenMessage;
var ra =
SaveScreenCommand.BuildSaveScreenResponse(msg.ScreenContent);
TelnetConnection.WriteToHost(
null, ra, this.Client.GetStream());
}
else if (message is ReadScreenMessage)
{
var msg = message as ReadScreenMessage;
var ra =
ReadScreenCommand.BuildReadScreenResponse(msg.ScreenContent);
TelnetConnection.WriteToHost(LogList, ra, this.Client.GetStream());
}
else if (message is Query5250ResponseMessage)
{
var msg = message as Query5250ResponseMessage;
var ra = Query5250Response.BuildQuery5250Response();
TelnetConnection.WriteToHost(LogList, ra, this.Client.GetStream());
}
// send the DataBytes contained in the message to the server.
else if (message is SendDataMessage)
{
var msg = message as SendDataMessage;
TelnetConnection.WriteToHost(
LogList, msg.DataBytes, this.Client.GetStream());
}
else if (message is GeneralThreadMessage)
{
var generalMessage = message as GeneralThreadMessage;
switch (generalMessage.MessageCode)
{
case ThreadMessageCode.ClearLog:
{
this.LogList.Clear();
break;
}
}
}
}
}
}
finally
{
// in case anyone waiting for this thread to end. Signal the ended event.
ThreadEndedEvent.Set();
}
}
public void EntryPoint()
{
this.ThreadEndedEvent.Reset();
try
{
// loop receiving from the server until:
// - the foreground thread wants to shutdown the connection. It has set
// the ShutdownFlag event.
while ((ShutdownFlag.State == false))
{
var message = InputQueue.WaitAndDequeue(this.ShutdownFlag.EventObject);
if (message != null)
{
// list of defined screens. Message sent by the UI thread. Idea being
// that as a new screen is defined want to send message to this match
// thread so it will update itself with the current list.
if (message is AssignScreenDefnListMessage)
{
var assignMessage = message as AssignScreenDefnListMessage;
this.ScreenDefnList = assignMessage.ScreenDefnList;
}
else if (message is GeneralThreadMessage)
{
var generalMessage = message as GeneralThreadMessage;
var screenContent = generalMessage.ScreenContent;
switch (generalMessage.MessageCode)
{
// message sent by MasterThread. MasterThread has completed the
// screen content. It sends message to PaintThread. And this msg
// to this MatchThread.
case ThreadMessageCode.MatchScreenContentToScreenDefn:
{
var matchDefn = FindMatchingScreenDefn(
screenContent, this.ScreenDefnList);
// send match results to paint thread and tnClient window.
// ( send results whether a match found or not. )
var matchMessage =
new MatchScreenDefnMessage(matchDefn, screenContent);
this.PaintThread.PostInputMessage(matchMessage);
// signal back to tnClient window.
this.TelnetWindowInputSignal(matchMessage);
break;
}
}
}
else if (message is CaptureAttributesMessage)
{
var captureMessage = message as CaptureAttributesMessage;
this.CaptureAuto = captureMessage.CaptureAuto;
this.CaptureFolderPath = captureMessage.CaptureFolderPath;
}
}
}
}
finally
{
// in case anyone waiting for this thread to end. Signal the ended event.
ThreadEndedEvent.Set();
}
}
public void EntryPoint()
{
this.ThreadEndedEvent.Reset();
try
{
// loop receiving from the server until:
// - the foreground thread wants to shutdown the connection. It has set
// the ShutdownFlag event.
while ((ShutdownFlag.State == false))
{
var message = InputQueue.WaitAndDequeue(this.ShutdownFlag.EventObject);
if (message != null)
{
if (message is PaintCanvasMessage)
{
var paintMessage = message as PaintCanvasMessage;
var screenContent = paintMessage.ScreenContent;
var bi = Window.Dispatcher.BeginInvoke(
DispatcherPriority.Input, new ThreadStart(
() =>
{
if (screenContent is WindowScreenContent)
{
var windowScreenContent = screenContent as WindowScreenContent;
// find the existing ItemCanvas associated with the
// WindowScreenContent.
var itemCanvas = screenContent.FindItemCanvas(this.TelnetCanvas);
// var itemCanvas = TelnetCanvas.FindChildCanvas(screenContent.ContentNum);
if (itemCanvas == null)
{
itemCanvas = windowScreenContent.CreateItemCanvas(
TelnetCanvas, MasterThread, this);
}
screenContent.PaintScreenContent(itemCanvas);
}
else
{
screenContent.PaintScreenContent(this.TelnetCanvas);
}
}));
}
else if (message is ClearUnitMessage)
{
var cu = message as ClearUnitMessage;
this.TelnetCanvas.ContentNum = cu.ContentNum;
}
else if (message is KeyboardInputMessage)
{
var kbInput = message as KeyboardInputMessage;
}
else if (message is GeneralThreadMessage)
{
var generalMessage = message as GeneralThreadMessage;
var screenContent = generalMessage.ScreenContent;
switch (generalMessage.MessageCode)
{
case ThreadMessageCode.ClearLog:
{
this.LogList.Clear();
break;
}
case ThreadMessageCode.ReportVisualItems:
{
IEnumerable <string> report = null;
var bi = Window.Dispatcher.BeginInvoke(
DispatcherPriority.Input, new ThreadStart(
() =>
{
report = screenContent.ReportVisualItems(this.TelnetCanvas);
}));
bi.Wait();
this.LogList.AddReport(Direction.none, report);
break;
}
}
}
// message sent by TimerTick method of the HoverTimer class.
// Call draw hover box method on the UI thread.
// ( should be changed to push processing to a HoverThread. Hover
// processing like ODBC calls to server should not be done on the
// UI thread. )
else if (message is HoverMessageBase)
{
if (message is CanvasHoverMessage)
{
var hoverMessage = message as CanvasHoverMessage;
var bi = Window.Dispatcher.BeginInvoke(
DispatcherPriority.Input, new ThreadStart(
() =>
{
hoverMessage.ItemCanvas.DrawHoverBox(hoverMessage.HoverPos);
}));
}
else if (message is SuspendHoverMessage)
{
this.TelnetCanvas.HoverTimer.SuspendHover();
}
else if (message is ResumeHoverMessage)
{
this.TelnetCanvas.HoverTimer.ResumeHover();
}
else if (message is DelayHoverMessage)
{
this.TelnetCanvas.HoverTimer.DelayHover();
}
}
// message from match thread. Telling PaintThread of latest match.
else if (message is MatchScreenDefnMessage)
{
var screenDefn = message as MatchScreenDefnMessage;
var bi = Window.Dispatcher.BeginInvoke(
DispatcherPriority.Input, new ThreadStart(
() =>
{
this.TelnetCanvas.MatchScreenDefn = screenDefn.ScreenDefn;
}));
}
}
}
}
finally
{
// in case anyone waiting for this thread to end. Signal the ended event.
ThreadEndedEvent.Set();
}
}
public void EntryPoint()
{
this.ThreadEndedEvent.Reset();
try
{
// loop receiving from the server until:
// - the foreground thread wants to shutdown the connection. It has set
// the ShutdownFlag event.
while ((ShutdownFlag.State == false) &&
(this.ConnectionFailedEvent.State == false))
{
var message = InputQueue.WaitAndDequeue(
this.ShutdownFlag.EventObject, this.ConnectionFailedEvent.EventObject);
if (message != null)
{
if (message is DataStreamHeaderMessage)
{
var dshMessage = message as DataStreamHeaderMessage;
var dataBytes = new byte[] {
0x00, 0x0A, 0x12, 0xA0, 0x01, 0x02,
0x04, 0x00, 0x00, 0x01, 0xFF, 0xEF
};
var dataMessage = new SendDataMessage(dataBytes);
this.ToThread.PostInputMessage(dataMessage);
}
else if (message is DataStreamHeader)
{
var dsh = message as DataStreamHeader;
var dataBytes = new byte[] {
0x00, 0x0A, 0x12, 0xA0, 0x01, 0x02,
0x04, 0x00, 0x00, 0x01, 0xFF, 0xEF
};
var dataMessage = new SendDataMessage(dataBytes);
this.ToThread.PostInputMessage(dataMessage);
}
else if (message is PrinterDataBytesMessage)
{
var dataMessage = message as PrinterDataBytesMessage;
var dataBytes = dataMessage.DataBytes;
var dataBytesLength = dataBytes.Length;
// remove the IAC EOR from the end of the stream.
// ( the data stream may end with a partial control function which
// is continued in the next data stream. Do not want to
// confuse the FF EF EOR bytes as data bytes of the possible
// incomplete control function. )
{
var endBytes = dataBytes.Tail(2);
var cmdCode = endBytes.ParseTelnetCommandCode();
if ((cmdCode != null) && (cmdCode.Value == CommandCode.EOR))
{
dataBytesLength -= 2;
// dataBytes = dataBytes.SubArray(0, dataBytesLength);
}
}
// there are remaining bytes from the previous dataBytes message.
// insert these remaining bytes after the dataStreamHeader.
if (this.RemainingBytes != null)
{
dataBytes = dataBytes.SubArray(0, dataBytesLength);
var headerLength = dataBytes.GetDataStreamHeaderLength();
if (headerLength != null)
{
dataBytes =
dataBytes.Insert(headerLength.Value, this.RemainingBytes);
dataBytesLength += this.RemainingBytes.Length;
}
}
// parse the bytes.
var rv = ServerDataStream.ParseByteArray(dataBytes, dataBytesLength);
var wrkstnCmdList = rv.Item1;
var responseList = rv.Item2;
var dsh = rv.Item3;
var telList = rv.Item4;
var funcList = rv.Item5;
// bytes at the end of the data stream that were not recognized as
// complete SCS function codes. Save now and add to the front of the
// next data stream that arrives. ( add to front after the data
// stream header. )
this.RemainingBytes = rv.Item6;
if (1 == 1)
{
this.OpenDoc = PrintToPdf(dsh, funcList, this.OpenDoc);
}
var respBytes = new byte[] {
0x00, 0x0A, 0x12, 0xA0, 0x01, 0x02,
0x04, 0x00, 0x00, 0x01, 0xFF, 0xEF
};
var respMessage = new SendDataMessage(respBytes);
this.ToThread.PostInputMessage(respMessage);
}
else if (message is GeneralThreadMessage)
{
var generalMessage = message as GeneralThreadMessage;
switch (generalMessage.MessageCode)
{
case ThreadMessageCode.ClearLog:
{
break;
}
}
}
else if (message is ExchangeMessage)
{
var exchangeMessage = message as ExchangeMessage;
if (exchangeMessage.MessageCode == ThreadMessageCode.GetScreenContent)
{
}
}
}
}
}
finally
{
// in case anyone waiting for this thread to end. Signal the ended event.
ThreadEndedEvent.Set();
}
}
public void EntryPoint()
{
this.ThreadEndedEvent.Reset();
var master = BaseMaster_InitialSetup();
try
{
// loop receiving from the server until:
// - the foreground thread wants to shutdown the connection. It has set
// the ShutdownFlag event.
while ((ShutdownFlag.State == false) &&
(this.ConnectionFailedEvent.State == false))
{
var message = InputQueue.WaitAndDequeue(
this.ShutdownFlag.EventObject, this.ConnectionFailedEvent.EventObject);
if (message != null)
{
if (message is WorkstationCommandListMessage)
{
var cmdList = (message as WorkstationCommandListMessage).WorkstationCommandList;
var rv = this.BaseMaster.Apply(
cmdList, this.ToThread, this.PaintThread, this.LogList);
bool wtdApplied = rv.Item1;
this.BaseMaster = rv.Item2;
// signal the paint thread to paint the canvas with the screen
// content block.
if (wtdApplied == true)
{
this.BaseMaster.PostAidKey = this.PostAidKey;
this.PostAidKey = null;
var masterCopy = this.BaseMaster.Copy();
var content = masterCopy.GetWorkingContentBlock();
var paintMessage = new PaintCanvasMessage(content);
this.PaintThread.PostInputMessage(paintMessage);
}
// send another copy of the screenContent to the match thread.
// Match thread will match the screen to the screen definitions.
// Looking for screen id, hover code, help text, etc.
if (wtdApplied == true)
{
var masterCopy = this.BaseMaster.Copy();
var content = masterCopy.GetWorkingContentBlock();
this.MatchThread.PostInputMessage(
ThreadMessageCode.MatchScreenContentToScreenDefn, content);
}
}
else if (message is KeyboardInputMessage)
{
var kbInput = message as KeyboardInputMessage;
if (kbInput.Text != null)
{
master = this.BaseMaster.GetWorkingContentBlock();
master.ApplyInput(kbInput);
}
}
// message sent from UI thread when the caret is moved. See the
// ItemCanvas class.
else if (message is CaretMoveMessage)
{
var caretMove = message as CaretMoveMessage;
master = this.BaseMaster.GetWorkingContentBlock();
master.ApplyCaretMove(caretMove);
}
// enter key has been pressed. UI thread sent the message to this
// Master thread. Master thread relays the message to the
// ToThread along with a copy of the master ScreenContent. ToThread
// creates and sends the response data stream based on the master
// screen content.
else if (message is AidKeyResponseMessage)
{
var msg = message as AidKeyResponseMessage;
this.PostAidKey = msg.AidKey;
msg.ScreenContent = this.BaseMaster.Copy();
ToThread.PostInputMessage(msg);
}
else if (message is GeneralThreadMessage)
{
var generalMessage = message as GeneralThreadMessage;
switch (generalMessage.MessageCode)
{
case ThreadMessageCode.ClearLog:
{
this.LogList.Clear();
break;
}
// report visual items. Add screenContent to the message and
// send it to PaintThread.
case ThreadMessageCode.ReportVisualItems:
{
generalMessage.ScreenContent = this.BaseMaster.Copy();
PaintThread.PostInputMessage(generalMessage);
break;
}
}
}
else if (message is ExchangeMessage)
{
var exchangeMessage = message as ExchangeMessage;
if (exchangeMessage.MessageCode == ThreadMessageCode.GetScreenContent)
{
master = this.BaseMaster.GetWorkingContentBlock();
var masterCopy = master.Copy();
exchangeMessage.PostReplyMessage(masterCopy);
}
}
}
}
}
finally
{
// in case anyone waiting for this thread to end. Signal the ended event.
ThreadEndedEvent.Set();
}
}
public void EntryPoint()
{
this.ThreadEndedEvent.Reset();
try
{
byte[] buf = new byte[99999];
this.ConnectionFailedException = null;
var gotRead = new ManualResetEvent(false);
IAsyncResult br = null;
int bytesRead = 0;
WaitHandle[] handles = new WaitHandle[3];
// loop receiving from the server until:
// - the foreground thread wants to shutdown the connection. It has set
// the ShutdownFlag event.
// - the connection to the server has failed.
while ((ShutdownFlag.State == false) &&
(ConnectionFailedException == null))
{
AsyncCallback callBack = null;
callBack = ar =>
{
try
{
bytesRead = this.Client.GetStream().EndRead(ar);
gotRead.Set(); // set the gotRead event. one of the events the
// WaitAny is waiting on.
}
catch (ObjectDisposedException)
{
bytesRead = 0;
}
catch (InvalidOperationException)
{
bytesRead = 0;
}
};
// dequeue and process any message in the InputQueue.
if (this.InputQueue.Count > 0)
{
ReadAndProcessInputQueue();
continue;
}
try
{
// start a socket read. ( do not start a new read on every iteration
// of this loop. Something may have arrived on the InputQueue.
// Meaning the read of the prior iteration is active and is waiting
// to complete. )
if (br == null)
{
br = this.Client.GetStream().BeginRead(
buf, 0, buf.Length, callBack, null);
}
// wait for socket read to complete ( gotRead event is set. ) Or for
// something to arrive in the InputQueue.
handles[0] = this.ShutdownFlag.EventObject;
handles[1] = gotRead;
handles[2] = this.InputQueue.GotMessageEvent;
var ix = WaitHandle.WaitAny(handles);
if (ix == 1)
{
br = null;
gotRead.Reset();
if (bytesRead > 0)
{
byte[] recvBytes = LoadReceivedBytes(buf, bytesRead);
TrafficLogFile.Write(Direction.Read, recvBytes);
// print to printer data stream has started. route direct to
// printer thread.
if ((this.TypeDevice != null) &&
(this.TypeDevice.Value == TypeTelnetDevice.Printer))
{
var printerMessage = new PrinterDataBytesMessage(recvBytes);
PostToProcessQueue(printerMessage);
}
else
{
ProcessAndPostBytesReceived(recvBytes);
}
}
}
}
catch (Exception excp)
{
this.ConnectionFailedException = excp;
this.ConnectionFailedEvent.Set();
}
}
}
finally
{
// in case anyone waiting for this thread to end. Signal the ended event.
ThreadEndedEvent.Set();
}
}
