コード例 #1
0
        ParseByteArray(byte[] ByteArray, int ArrayLx = -1, string DataStreamName = "")
        {
            if (ArrayLx == -1)
            {
                ArrayLx = ByteArray.Length;
            }

            var inputArray      = new InputByteArray(ByteArray, ArrayLx);
            var sessionSettings = new SessionSettings();

            var rv =
                ServerDataStream.ParseDataStream(inputArray, sessionSettings,
                                                 DataStreamName);
            var wrkstnCmdList    = rv.Item1;
            var responseItemList = rv.Item2;
            var dsh      = rv.Item3;
            var telList  = rv.Item4;
            var funcList = rv.Item5;

            byte[] remainingBytes = null;
            if (inputArray.RemainingLength > 0)
            {
                remainingBytes = inputArray.PeekBytes();
                var report = remainingBytes.ToHexReport(16);
            }

            return(new Tuple <WorkstationCommandList, ResponseItemList,
                              DataStreamHeader, TelnetCommandList, ControlFunctionList, byte[]>(
                       wrkstnCmdList, responseItemList, dsh, telList, funcList, remainingBytes));
        }
コード例 #2
0
        public static IEnumerable <string> ParseAndReportByteArray(
            byte[] ByteArray, string DataStreamName)
        {
            var rv            = ServerDataStream.ParseByteArray(ByteArray, -1, DataStreamName);
            var wrkstnCmdList = rv.Item1;
            var responseList  = rv.Item2;
            var dsHeader      = rv.Item3;
            var telList       = rv.Item4;

            var report = ReportParseResults(dsHeader, wrkstnCmdList, responseList, telList);

            return(report);
        }
コード例 #3
0
        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));
        }