private static IEnumerable <string> ReportParseResults( DataStreamHeader dsHeader, WorkstationCommandList wrkstnCmdList, ResponseItemList responseList, TelnetCommandList telList) { var report = new List <string>(); if (dsHeader != null) { report.AddRange(dsHeader.ToColumnReport()); } if (wrkstnCmdList != null) { report.AddRange(wrkstnCmdList.ToColumnReport()); } if (responseList != null) { report.AddRange(responseList.ReportResponseItems()); } if (telList != null) { report.AddRange(telList.ToColumnReport()); } return(report); }
private void ProcessAndPostBytesReceived(byte[] recvBytes) { // load bytes received from the server into InputArray. var inputArray = new InputByteArray(recvBytes); WorkstationCommandList wipCmdList = null; bool badDataLogged = false; while (inputArray.IsEof() == false) { var rv = ParseAndPostInputArray(inputArray, wipCmdList); wipCmdList = rv.Item1; var gotSomething = rv.Item2; // nothing parsed. And there is data remaining. This is an error. if ((gotSomething == false) && (inputArray.IsEof() == false)) { if (badDataLogged == false) { LogBadData(inputArray); badDataLogged = true; } inputArray.GetByte(); // advance by 1 byte in byte stream. } } }
public static Tuple <WorkstationCommandList, TelnetLogList> GetAndParseWorkstationCommandList( NetworkStreamBackedInputByteArray InputArray, SessionSettings SessionSettings) { TelnetLogList logList = new TelnetLogList(); var wrkstnCmdList = new WorkstationCommandList(); var dsh = new DataStreamHeader(InputArray); if (dsh != null) { logList.AddItems(Direction.Read, dsh.ToReportLines( ), true); } if ((dsh != null) && (dsh.Errmsg == null)) { bool lastCmdWasTelnet_EOR = false; while (dsh != null) { // read available bytes from input stream. if (InputArray.IsEof() && (lastCmdWasTelnet_EOR == false)) { var log = InputArray.ReadFromNetworkStream(5, 5); logList.AddItems(log); } // no input data to process. if (InputArray.IsEof()) { break; } lastCmdWasTelnet_EOR = false; // check for IAC EOR var telCode = InputArray.PeekTelnetCommandCode(CommandCode.EOR); if (telCode != null) { var telCmd = InputArray.NextTelnetCommand(); logList.AddItems(Direction.Read, telCmd.ToReportLines(), true); lastCmdWasTelnet_EOR = true; } // process the input as workstation data stream commands. else { var rv = ParseAndProcessWorkstationCommand(InputArray, dsh); var workstationCommand = rv.Item1; dsh = rv.Item3; logList.AddItems(rv.Item4); if (workstationCommand != null) { wrkstnCmdList.Add(workstationCommand); } } } } return(new Tuple <WorkstationCommandList, TelnetLogList>(wrkstnCmdList, logList)); }
public static Tuple <bool, TelnetLogList> PaintCanvas( this WorkstationCommandList CmdList, ItemCanvas ItemCanvas, TelnetLogList LogList = null) { TelnetLogList logList = new TelnetLogList(); bool drawDone = false; OneRowCol caret = null; foreach (var cmdBase in CmdList) { if ((cmdBase is ClearUnitCommand) || (cmdBase is ClearUnitAlternateCommand)) { ItemCanvas.EraseScreen(); } else if (cmdBase is WriteToDisplayCommand) { // store the painted from wtdCommand in the ItemCanvas itself. Used when // ScreenDefn imports a screen layout into the defn of a screen. ItemCanvas.WriteToDisplayCommand = cmdBase as WriteToDisplayCommand; bool eraseScreen = false; var rv = ItemCanvas.WriteToDisplayCommand.PaintCanvas( ItemCanvas, eraseScreen, LogList); var localDrawDone = rv.Item1; if (rv.Item2 != null) { caret = rv.Item2; } if (localDrawDone == true) { drawDone = true; } } } ItemCanvas.PositionCaret(caret); return(new Tuple <bool, TelnetLogList>(drawDone, logList)); }
/// <summary> /// run the BuildShowItemList method against the first WriteToDisplay command in /// the list of workstation commands. /// </summary> /// <param name="LogList"></param> /// <returns></returns> public static ShowItemList BuildShowItemList( this WorkstationCommandList CommandList, ScreenDim ScreenDim, TelnetLogList LogList) { ShowItemList showItemList = null; OneRowCol caret = null; foreach (var workstationCommand in CommandList) { if (workstationCommand is WriteToDisplayCommand) { var wtdCmd = workstationCommand as WriteToDisplayCommand; TelnetLogList logList = new TelnetLogList(); var rv = wtdCmd.BuildShowItemList(ScreenDim, logList); showItemList = rv.Item1; if (rv.Item2 != null) { caret = rv.Item2; } break; } } return(showItemList); }
/// <summary> /// apply the commands of the workstation command list to the screen content /// block. /// </summary> /// <param name="applyMaster"></param> /// <param name="CmdList"></param> /// <param name="ToThread"></param> /// <param name="LogList"></param> /// <returns></returns> public static Tuple <bool, ScreenContent> Apply( this ScreenContent InBaseMaster, WorkstationCommandList CmdList, ToThread ToThread, PaintThread PaintThread, TelnetLogList LogList) { bool wtdApplied = false; var baseMaster = InBaseMaster; var master = baseMaster.GetWorkingContentBlock(); foreach (var cmdBase in CmdList) { if (cmdBase is ClearUnitCommand) { var rv = ProcessClearUnit(baseMaster, baseMaster.ScreenDim, PaintThread); baseMaster = rv.Item1; master = rv.Item2; } // same as ClearUnit. Only signals that a wide screen to be used. else if (cmdBase is ClearUnitAlternateCommand) { var cua = cmdBase as ClearUnitAlternateCommand; // screen size. ScreenDim screenDim; if (cua.RequestByte == 0x00) { screenDim = new ScreenDim(27, 132); } else { screenDim = new ScreenDim(24, 80); } var rv = ProcessClearUnit(baseMaster, screenDim, PaintThread); baseMaster = rv.Item1; master = rv.Item2; } // apply the orders of the WriteToDisplay command. else if (cmdBase is WriteToDisplayCommand) { var curMaster = master.Apply(cmdBase as WriteToDisplayCommand); master = curMaster; wtdApplied = true; } else if (cmdBase is ReadMdtFieldsCommand) { master.HowRead = HowReadScreen.ReadMdt; } // save screen command. Build response, send back to server. else if (cmdBase is SaveScreenCommand) { var msg = new SaveScreenMessage(master.Copy()); ToThread.PostInputMessage(msg); } // read screen command. Build response, send back to server. else if (cmdBase is ReadScreenCommand) { var msg = new ReadScreenMessage(master.Copy()); ToThread.PostInputMessage(msg); } else if (cmdBase is WriteStructuredFieldCommand) { var wsfCmd = cmdBase as WriteStructuredFieldCommand; if (wsfCmd.RequestCode == WSF_RequestCode.Query5250) { var msg = new Query5250ResponseMessage(); ToThread.PostInputMessage(msg); } } else if (cmdBase is WriteSingleStructuredFieldCommand) { } } return(new Tuple <bool, ScreenContent>(wtdApplied, baseMaster)); }
ParseDataStream( InputByteArray inputArray, SessionSettings sessionSettings, string DataStreamName, TypeTelnetDevice?TypeDevice = null) { var accumCmdList = new WorkstationCommandList(); var responseItemList = new ResponseItemList(); TelnetCommandList telList = null; ResponseHeader curRespHeader = null; ResponseHeader nextRespHeader = null; DataStreamHeader dsh = null; ControlFunctionList funcList = null; bool didParse = true; while ((didParse == true) && (inputArray.RemainingLength > 0)) { didParse = false; curRespHeader = nextRespHeader; nextRespHeader = null; if ((didParse == false) && (dsh == null)) { var telCmd = inputArray.NextTelnetCommand(); if (telCmd != null) { if (telList == null) { telList = new TelnetCommandList(); } telList.Add(telCmd); var s1 = telCmd.ToString(); didParse = true; } } // parse the data stream header. if ((didParse == false) && (dsh == null)) { var code = inputArray.PeekDataStreamCode(); if (code != null) { var rv = DataStreamHeader.Factory(inputArray); dsh = rv.Item1; didParse = true; // update the type of device depending on data stream header stream // code. if ((TypeDevice == null) && (dsh != null) && (dsh.Errmsg == null)) { TypeDevice = dsh.StreamCode.ToTypeTelnetDevice(); } } } // parse as a sequence of workstation commands. if (didParse == false) { if ((TypeDevice == null) || (TypeDevice.Value != TypeTelnetDevice.Printer)) { var rv = Process5250.ParseWorkstationCommandList( inputArray, sessionSettings); var anotherDsh = rv.Item1; var wrkstnCmdList = rv.Item2; if ((anotherDsh != null) && (anotherDsh.Errmsg == null)) { didParse = true; dsh = anotherDsh; } // draw the fields and literals on the canvas. if (wrkstnCmdList?.Count > 0) { accumCmdList.Append(wrkstnCmdList); didParse = true; } } } // parse as sequence of SCS control functions. ( printer data stream ). if (didParse == false) { if ((TypeDevice == null) || (TypeDevice.Value == TypeTelnetDevice.Printer)) { var rv = ControlFunctionList.ParseDataStream(inputArray); if (rv.Item1?.Count > 0) { didParse = true; funcList = rv.Item1; } } } // parse as response stream header. if ((didParse == false) && (ResponseHeader.IsResponseHeader(inputArray).Item1 == true)) { curRespHeader = new ResponseHeader(inputArray); didParse = true; responseItemList.Add(curRespHeader); var rv = Response5250.ParseResponseStream(inputArray, curRespHeader); responseItemList.Append(rv.Item1); } } return(new Tuple <WorkstationCommandList, ResponseItemList, DataStreamHeader, TelnetCommandList, ControlFunctionList>( accumCmdList, responseItemList, dsh, telList, funcList)); }
public static void ProcessAndPaint( this WorkstationCommandList CmdList, TcpClient TcpClient, ItemCanvas ItemCanvas, Window Window, TelnetLogList LogList = null) { OneRowCol caret = null; foreach (var cmdBase in CmdList) { if ((cmdBase is ClearUnitCommand) || (cmdBase is ClearUnitAlternateCommand)) { ItemCanvas.EraseScreen(); caret = null; } else if (cmdBase is WriteToDisplayCommand) { bool doEraseScreen = false; var WTD_Command = cmdBase as WriteToDisplayCommand; ItemCanvas.WriteToDisplayCommand = WTD_Command; var localCaret = ItemCanvas.PaintScreen(WTD_Command, doEraseScreen, LogList); if (localCaret != null) { caret = localCaret; } } else if (cmdBase is ReadMdtFieldsCommand) { ItemCanvas.HowRead = HowReadScreen.ReadMdt; } // save screen command. Build response, send back to server. else if (cmdBase is SaveScreenCommand) { var ra = SaveScreenCommandExt.BuildSaveScreenResponse( ItemCanvas.VisualItems, ItemCanvas.CaretCursor); // send response stream back to server. if (TcpClient != null) { TelnetConnection.WriteToHost( null, ra, TcpClient.GetStream()); } } else if (cmdBase is WriteStructuredFieldCommand) { var wsfCmd = cmdBase as WriteStructuredFieldCommand; if (wsfCmd.RequestCode == WSF_RequestCode.Query5250) { var ra = Query5250Response.BuildQuery5250Response(); // send response stream back to server. if (TcpClient != null) { TelnetConnection.WriteToHost(LogList, ra, TcpClient.GetStream()); } } } else if (cmdBase is WriteSingleStructuredFieldCommand) { } } ItemCanvas.PositionCaret(caret); }
ProcessWorkstationDataStream( this ServerConnectPack ConnectPack, ScreenVisualItems VisualItems, CanvasPositionCursor Caret) { WorkstationCommandList workstationCmdList = null; List <WriteToDisplayCommand> wtdCmdList = null; DataStreamHeader dsh = null; var returnCmdList = new WorkstationCommandList(); HowReadScreen?howRead = null; var logList = new TelnetLogList(); bool gotEOR = false; while (gotEOR == false) { // input array is eof. Exit loop if have read a READ workstn command. // Otherwise, read from server. if (ConnectPack.ReadBlocks.IsEmpty == true) { if (howRead != null) { break; } } var item = ConnectPack.ReadBlocks.WaitAndDequeue(); if (item is DataStreamHeader) { dsh = item as DataStreamHeader; continue; } gotEOR = true; if (item is WorkstationCommandList) { workstationCmdList = item as WorkstationCommandList; foreach (var workstationCmd in workstationCmdList) { if (workstationCmd is ClearUnitCommand) { returnCmdList.Add(workstationCmd); } // WTD command. Add to list of WTD commands. This list is returned to // the caller of this method. else if (workstationCmd is WriteToDisplayCommand) { returnCmdList.Add(workstationCmd); var wtdCommand = workstationCmd as WriteToDisplayCommand; if (wtdCmdList == null) { wtdCmdList = new List <WriteToDisplayCommand>(); } wtdCmdList.Add(wtdCommand); } else if (workstationCmd is ReadMdtFieldsCommand) { howRead = HowReadScreen.ReadMdt; } // save screen command. Build response, send back to server. else if (workstationCmd is SaveScreenCommand) { var ra = SaveScreenCommandExt.BuildSaveScreenResponse(VisualItems, Caret); // send response stream back to server. { TelnetConnection.WriteToHost( logList, ra, ConnectPack.TcpClient.GetStream()); gotEOR = false; } } else if (workstationCmd is WriteStructuredFieldCommand) { var wsfCmd = workstationCmd as WriteStructuredFieldCommand; if (wsfCmd.RequestCode == WSF_RequestCode.Query5250) { var ra = Query5250Response.BuildQuery5250Response(); // send response stream back to server. { TelnetConnection.WriteToHost( logList, ra, ConnectPack.TcpClient.GetStream()); gotEOR = false; } } } } } } return(new Tuple <HowReadScreen?, List <WriteToDisplayCommand>, TelnetLogList, WorkstationCommandList, DataStreamHeader, bool>( howRead, wtdCmdList, logList, returnCmdList, dsh, gotEOR)); }
ProcessWorkstationDataStream( this ConnectedSocketPack SocketPack, ScreenVisualItems VisualItems, CanvasPositionCursor Caret) { WorkstationCommandList workstationCmdList = null; List <WriteToDisplayCommand> wtdCmdList = null; DataStreamHeader dsh = null; var returnCmdList = new WorkstationCommandList(); HowReadScreen?howRead = null; var logList = new TelnetLogList(); bool gotEOR = false; while (gotEOR == false) { // input array is eof. Exit loop if have read a READ workstn command. // Otherwise, read from server. if (SocketPack.InputArray.IsEof() == true) { if (howRead != null) { break; } { var log = SocketPack.InputArray.ReadFromNetworkStream(10, 60); logList.AddItems(log); if (SocketPack.InputArray.IsEof() == true) { break; } } } // peek at the input stream from server. Classify the data that is next // to receive. var typeData = ServerDataStream.PeekServerCommand(SocketPack.InputArray); // input data not recogizied. Not a 5250 data strem header. if (typeData == null) { logList.AddItem(Direction.Read, "Unknown data stream data"); logList.AddItems( Direction.Read, SocketPack.InputArray.PeekBytes().ToHexReport(16)); break; } if (typeData.Value == TypeServerData.workstationHeader) { { var rv = Process5250.GetAndParseWorkstationCommandList( SocketPack.InputArray, SocketPack.Settings); dsh = rv.Item1; workstationCmdList = rv.Item2; logList.AddItems(rv.Item3); gotEOR = rv.Item4; } foreach (var workstationCmd in workstationCmdList) { if (workstationCmd is ClearUnitCommand) { returnCmdList.Add(workstationCmd); } // WTD command. Add to list of WTD commands. This list is returned to the // caller of this method. else if (workstationCmd is WriteToDisplayCommand) { returnCmdList.Add(workstationCmd); var wtdCommand = workstationCmd as WriteToDisplayCommand; if (wtdCmdList == null) { wtdCmdList = new List <WriteToDisplayCommand>(); } wtdCmdList.Add(wtdCommand); } else if (workstationCmd is ReadMdtFieldsCommand) { howRead = HowReadScreen.ReadMdt; } // save screen command. Build response, send back to server. else if (workstationCmd is SaveScreenCommand) { var ra = SaveScreenCommandExt.BuildSaveScreenResponse(VisualItems, Caret); // send response stream back to server. { TelnetConnection.WriteToHost(logList, ra, SocketPack.TcpStream); gotEOR = false; } } else if (workstationCmd is WriteStructuredFieldCommand) { var wsfCmd = workstationCmd as WriteStructuredFieldCommand; if (wsfCmd.RequestCode == WSF_RequestCode.Query5250) { var ra = Query5250Response.BuildQuery5250Response(); // send response stream back to server. { TelnetConnection.WriteToHost(logList, ra, SocketPack.TcpStream); gotEOR = false; } } } else if (workstationCmd is WriteSingleStructuredFieldCommand) { } } } } return(new Tuple <HowReadScreen?, List <WriteToDisplayCommand>, TelnetLogList, WorkstationCommandList, DataStreamHeader, bool>( howRead, wtdCmdList, logList, returnCmdList, dsh, gotEOR)); }
public WorkstationCommandListMessage( WorkstationCommandList WorkstationCommandList) { this.WorkstationCommandList = WorkstationCommandList; }
ProcessWorkstationDataStream(this ConnectedSocketPack SocketPack) { WorkstationCommandList workstationCmdList = null; List <WriteToDisplayCommand> wtdCmdList = null; HowReadScreen?howRead = null; var logList = new TelnetLogList(); while (true) { // input array is eof. Exit loop if have read a READ workstn command. // Otherwise, read from server. if (SocketPack.InputArray.IsEof( ) == true) { if (howRead != null) { break; } { var log = SocketPack.InputArray.ReadFromNetworkStream(20, 30); logList.AddItems(log); if (SocketPack.InputArray.IsEof() == true) { break; } } } // peek at the input stream from server. Classify the data that is next // to receive. var typeData = ServerDataStream.PeekServerCommand(SocketPack.InputArray); // input data not recogizied. Not a 5250 data strem header. if (typeData == null) { logList.AddItem(Direction.Read, "Unknown data stream data"); logList.AddItems( Direction.Read, SocketPack.InputArray.PeekBytes().ToHexReport(16)); break; } if (typeData.Value == TypeServerData.workstationHeader) { { var rv = Process5250.GetAndParseWorkstationCommandList( SocketPack.InputArray, SocketPack.Settings); workstationCmdList = rv.Item1; logList.AddItems(rv.Item2); } foreach (var workstationCmd in workstationCmdList) { if (workstationCmd is ClearUnitCommand) { } else if (workstationCmd is WriteToDisplayCommand) { var wtdCommand = workstationCmd as WriteToDisplayCommand; if (wtdCmdList == null) { wtdCmdList = new List <WriteToDisplayCommand>(); } wtdCmdList.Add(wtdCommand); } else if (workstationCmd is ReadMdtFieldsCommand) { howRead = HowReadScreen.ReadMdt; } // save screen command. Build response, send back to server. else if (workstationCmd is SaveScreenCommand) { var ra = SaveScreenCommand.BuildSaveScreenResponse(); Debug.WriteLine("Response: " + ra.ToHex(' ')); // send response stream back to server. { TelnetConnection.WriteToHost(logList, ra, SocketPack.TcpStream); } // BgnTemp logList.AddSpecialItem(LogItemSpecial.NewGeneration); // EndTemp } else if (workstationCmd is WriteStructuredFieldCommand) { var wsfCmd = workstationCmd as WriteStructuredFieldCommand; if (wsfCmd.RequestCode == WSF_RequestCode.Query5250) { var ra = Query5250Response.BuildQuery5250Response(); Debug.WriteLine("Response: " + ra.ToHex(' ')); // send response stream back to server. { TelnetConnection.WriteToHost(logList, ra, SocketPack.TcpStream); } } } } } } return(new Tuple <HowReadScreen?, List <WriteToDisplayCommand>, TelnetLogList>( howRead, wtdCmdList, logList)); }
ParseWorkstationCommandList( InputByteArray InputArray, SessionSettings SessionSettings) { var wrkstnCmdList = new WorkstationCommandList(); DataStreamHeader dsh = null; bool gotEOR = false; bool needMoreBytes = false; string errmsg = null; if (InputArray.IsDataStreamHeader()) { var rv = DataStreamHeader.Factory(InputArray); dsh = rv.Item1; errmsg = rv.Item2; } bool lastCmdWasTelnet_EOR = false; bool gotWorkstationCommand = true; gotEOR = false; while ((InputArray.IsEof( ) == false) && (gotEOR == false) && (gotWorkstationCommand == true)) { // no input data to process. lastCmdWasTelnet_EOR = false; gotWorkstationCommand = false; // check for IAC EOR var telCode = InputArray.PeekTelnetCommandCode(CommandCode.EOR); if (telCode != null) { var telCmd = InputArray.NextTelnetCommand(); lastCmdWasTelnet_EOR = true; gotEOR = true; } // process the input as workstation data stream commands. else { var rv = ParseAndProcessWorkstationCommand(InputArray); var workstationCommand = rv.Item1; var howRead = rv.Item2; if (workstationCommand != null) { wrkstnCmdList.Add(workstationCommand); gotWorkstationCommand = true; } } } // read available bytes from input stream. if (InputArray.IsEof() && (lastCmdWasTelnet_EOR == false)) { needMoreBytes = true; } return(new Tuple <DataStreamHeader, WorkstationCommandList, bool, bool>( dsh, wrkstnCmdList, gotEOR, needMoreBytes)); }
/// <summary> /// parse from current byte forward in the InputArray. Will either parse a /// telnet command or a workstation command. /// Route what was parsed to either the FromQueue or the MasterThread. Send to /// the FromQueue if still receiving telnet commands. Otherwise, send to the /// MasterThread. /// </summary> /// <param name="InputArray"></param> /// <param name="WipCmdList"></param> /// <returns></returns> private Tuple <WorkstationCommandList, bool> ParseAndPostInputArray( InputByteArray InputArray, WorkstationCommandList WipCmdList) { WorkstationCommandList wipCmdList = null; bool gotSomething = false; if (WipCmdList == null) { var telCmd = InputArray.NextTelnetCommand(); if (telCmd != null) { this.TelnetQueue.Enqueue(telCmd); gotSomething = true; } } if (gotSomething == false) { // peek at the input stream from server. Classify the data that is next // to receive. var typeData = ServerDataStream.PeekServerCommand(InputArray); if (typeData != null) { var rv = Process5250.ParseWorkstationCommandList( InputArray, this.SessionSettings); var dsh = rv.Item1; var workstationCmdList = rv.Item2; var gotEOR = rv.Item3; var needMoreBytes = rv.Item4; // update connectionComplete flag and typeDevice depending on the stream // code of the datastream header. if ((this.ConnectionComplete == false) && (dsh != null) && (dsh.StreamCode != null)) { this.ConnectionComplete = true; if (dsh.StreamCode.Value == DataStreamCode.Terminal) { this.TypeDevice = TypeTelnetDevice.Terminal; } else { this.TypeDevice = TypeTelnetDevice.Printer; } // post message to telnet queue so that the ConnectionThread on the // other end will know to shutdown. var message = new TelnetDeviceAttrMessage(this.TypeDevice.Value); this.TelnetQueue.Enqueue(message); } // got data stream header. if (dsh != null) { if (this.ConnectionComplete == false) { this.TelnetQueue.Enqueue(dsh); } else { var message = new DataStreamHeaderMessage(dsh); PostToProcessQueue(message); } gotSomething = true; } if (workstationCmdList != null) { gotSomething = true; } // accum the workstationCmdList if (WipCmdList == null) { wipCmdList = workstationCmdList; } else { wipCmdList = WipCmdList; wipCmdList.AddRange(workstationCmdList); } // got EOR. store the now completed workstationCmdList. if ((gotEOR == true) && (wipCmdList != null)) { var msg = new WorkstationCommandListMessage(wipCmdList); PostToProcessQueue(msg); gotSomething = true; wipCmdList = null; } } } return(new Tuple <WorkstationCommandList, bool>(wipCmdList, gotSomething)); }