TelnetConnectAndNegotiate(
string Host, NegotiateSettings NegotiateSettings,
ConcurrentMessageQueue TelnetQueue, ToThread ToThread)
{
var sessionSettings = new SessionSettings();
TelnetLogList logList = null;
bool breakLoop = false;
// loop reading from NetworkStream and processing the telnet command.
// loop until break flag is set.
while (breakLoop == false)
{
var item = TelnetQueue.WaitAndPeek();
if ((item is TelnetCommand) == false)
{
break;
}
var telCmd = TelnetQueue.WaitAndDequeue() as TelnetCommand;
byte[] responseBytes = null;
{
var rv = ProcessTelnetCommand(telCmd, NegotiateSettings);
var cx = rv.Item1;
responseBytes = rv.Item2;
}
if ((responseBytes != null) && (responseBytes.Length > 0))
{
var dataMessage = new SendDataMessage(responseBytes);
ToThread.PostInputMessage(dataMessage);
}
}
return(new Tuple <SessionSettings, TelnetLogList>(
sessionSettings, logList));
}
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 static Tuple <List <ShowItemBase>, TelnetLogList> NextServerRequest(
NetworkStreamBackedInputByteArray InputArray,
NegotiateSettings NegotiateSettings,
bool ForceRead = false)
{
TelnetLogList logList = new TelnetLogList();
var showItemList = new ShowItemList();
while (true)
{
// read available bytes from input stream.
if (InputArray.IsEof())
{
var log = InputArray.ReadFromNetworkStream(5, 5, ForceRead);
logList.AddItems(log);
}
// no input data to process.
if (InputArray.IsEof())
{
break;
}
var buf = InputArray.PeekDataStreamHeader();
if (buf != null)
{
var dsh = new DataStreamHeader(InputArray);
logList.AddItems(Direction.Read, dsh.ToReportLines( ), true);
var rv = ParseAndProcessWorkstationCommand(InputArray, dsh);
var workstationCommand = rv.Item1;
showItemList = rv.Item2;
logList.AddItems(rv.Item4);
}
// check for IAC EOR
{
var telCode = InputArray.PeekTelnetCommandCode(CommandCode.EOR);
if (telCode != null)
{
var telCmd = InputArray.NextTelnetCommand();
logList.AddItems(Direction.Read, telCmd.ToReportLines(), true);
}
}
// peek and process input bytes as a telnet stmt. ( starts with IAC )
{
var telCmd = InputArray.NextTelnetCommand();
if (telCmd != null)
{
var rv = TelnetConnection.ProcessTelnetCommand(telCmd, NegotiateSettings);
var cx = rv.Item1;
var writeBytes = rv.Item2;
logList.AddItems(rv.Item3);
WriteToHost(logList, writeBytes, InputArray.NetStream);
}
}
}
return(new Tuple <List <ShowItemBase>, TelnetLogList>(showItemList, logList));
}
public static Tuple <int, byte[], TelnetLogList> ProcessTelnetCommand(
TelnetCommand TelnetCmd, NegotiateSettings NegotiateSettings,
bool doLog = false)
{
TelnetLogList logList = null;
if (doLog == true)
{
logList = new TelnetLogList();
}
int cx = 0;
var writeStream = new ByteArrayBuilder();
// write to the run log.
if (logList != null)
{
logList.AddItem(Direction.Read, TelnetCmd.ToString());
}
if (TelnetCmd.CmdCode == Enums.CommandCode.DO)
{
var replyStmt = TelnetCmd.BuildReply(NegotiateSettings);
writeStream.Append(replyStmt.ToBytes());
}
else if (TelnetCmd is NewEnvironCommand)
{
var envStmt = TelnetCmd as NewEnvironCommand;
cx = ProcessNewEnvironStatement(envStmt, writeStream, NegotiateSettings);
}
else if (TelnetCmd is TerminalTypeCommand)
{
var ttStmt = TelnetCmd as TerminalTypeCommand;
cx = ProcessTerminalTypeStatement(ttStmt, writeStream, NegotiateSettings);
}
else if ((TelnetCmd is EndOfRecordStatement) || (TelnetCmd is TransmitBinaryCommand))
{
if (TelnetCmd.CmdCode == Enums.CommandCode.DO)
{
var replyStmt = TelnetCmd.BuildReply(NegotiateSettings);
writeStream.Append(replyStmt.ToBytes());
if ((replyStmt.CmdCode == Enums.CommandCode.DO) &&
(replyStmt.Subject.IsEqual(TelnetSubject.TRANSMIT_BINARY)))
{
}
}
else if (TelnetCmd.CmdCode == Enums.CommandCode.WILL)
{
var replyStmt = TelnetCmd.BuildDoReply();
writeStream.Append(replyStmt.ToBytes());
}
}
return(new Tuple <int, byte[], TelnetLogList>(cx, writeStream.ToByteArray(), logList));
}
private void TelnetInitialConnect(
string ServerName, bool AutoConnect, string DeviceName,
string TerminalType)
{
var host = ServerName;
int port = 23;
SessionSettings sessionSettings = null;
// already connected.
if (this.ConnectPack?.IsConnected() == true)
{
MessageBox.Show("already connected to telnet server.");
return;
}
MainWindow.LogFile.ClearFile();
// TelnetNegotiateSettings
// - WILL EOR
// - WILL TERMINAL TYPE
// - TERMINAL TYPE
// - user name, terminal name
// TelnetCommand.Negotiate( negotiateSettings )
// returns TelnetSessionAttributes
// after negotiate, call method to send and receive 5250 DataStreamHeader
// followed by escape 04 orders
// code is receive 5250 command, render to screen, wait for screen AID key,
// send 5250 command response.
var negSettings = NegotiateSettings.Build5250Settings(
"SRICHTER", DeviceName, TerminalType);
// connect to the server.
var rv = ConnectToServer_StartServerThreads(ServerName, port);
this.ConnectPack = rv.Item1;
sessionSettings = rv.Item2;
if (this.ConnectPack.IsConnected() == true)
{
// send message to connect thread. This will run telnet device startup
// processing on a backround thread. This way problems do not lock up
// the UI.
{
var startupMessage = new TelnetStartupMessage(
this.TelnetQueue,
this.ConnectPack, negSettings, this, MainWindow_TelnetStartupComplete,
TypeTelnetDevice.Terminal);
this.ConnectThread.PostInputMessage(startupMessage);
}
}
}
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;
}
private static int ProcessNewEnvironStatement(
NewEnvironCommand Stmt, ByteArrayBuilder WriteStream,
NegotiateSettings NegotiateSettings)
{
int sendStmtCx = 0;
// got the stmt with the SEND parm. Send back the NEW_ENVIRON stmt with the IS parm.
if ((Stmt.SubOption != null) &&
(Stmt.SubOption.Value == TelnetOptionParm.SEND))
{
var neSend =
new NewEnvironCommand(Enums.CommandCode.SB, TelnetOptionParm.IS);
foreach (var newEnv in NegotiateSettings.SendNewEnvironList)
{
var optnVar = newEnv.ToOptionVariable(NegotiateSettings.SbsValuesDict);
neSend.AddOptionVar(optnVar);
}
int xx = 25;
if (xx == 26)
{
neSend.AddOptionVar(EnvironVarCode.VAR, "USER", "SRICHTER");
neSend.AddOptionVar(EnvironVarCode.VAR, "DEVNAME", "STEVE25");
// reply to newEnviron IBMRSEED stmt SEND statement.
if (Stmt.ContainsUserVar_IBMRSEED() == true)
{
byte[] clientSeed = new byte[8] {
0x55, 0x56, 0x59, 0x5a, 0x5b, 0x5c, 0x4c, 0x48
};
string passWord = "******";
string userName = "******";
var serverSeed = Stmt.IBMRSEED_SeedValue();
var substitutionPassword =
CipherCommon.EncryptPassword(passWord, userName, serverSeed, clientSeed);
neSend.AddOptionVar(EnvironVarCode.USERVAR, "IBMRSEED", clientSeed);
neSend.AddOptionVar(EnvironVarCode.USERVAR, "IBMSUBSPW", substitutionPassword);
}
}
WriteStream.Append(neSend.ToBytes());
// send the SE command immed after NEW-ENVIRON
{
var ts = new TelnetCommand(Enums.CommandCode.SE);
WriteStream.Append(ts.ToBytes());
}
}
return(sendStmtCx);
}
TelnetPrinterConnectAndNegotiate(
string Host, NegotiateSettings NegotiateSettings,
ConcurrentMessageQueue TelnetQueue,
ServerConnectPack ConnectPack, bool doLog = false)
{
var sessionSettings = new SessionSettings();
TelnetLogList logList = null;
// BgnTemp
doLog = true;
// EndTemp
if (doLog == true)
{
logList = new TelnetLogList();
}
bool breakLoop = false;
// loop reading from NetworkStream and processing the telnet command.
// loop until break flag is set.
while (breakLoop == false)
{
var item = TelnetQueue.WaitAndPeek();
if ((item is TelnetCommand) == false)
{
break;
}
var telCmd = TelnetQueue.WaitAndDequeue() as TelnetCommand;
byte[] responseBytes = null;
{
var rv = ProcessTelnetCommand(telCmd, NegotiateSettings, doLog);
var cx = rv.Item1;
responseBytes = rv.Item2;
if (doLog == true)
{
logList.AddItems(rv.Item3);
}
}
if ((responseBytes != null) && (responseBytes.Length > 0))
{
WriteToHost(logList, responseBytes, ConnectPack.TcpClient.GetStream());
}
}
return(new Tuple <SessionSettings, TelnetLogList>(
sessionSettings, logList));
}
/// <summary>
/// reply to the DO command with a WILL or WONT command as per NegotiateSettings.
/// </summary>
/// <param name="Settings"></param>
/// <returns></returns>
public TelnetCommand BuildReply(NegotiateSettings Settings)
{
TelnetCommand reply = null;
var option = this.Subject.Value;
if (Settings.OptionDict.ContainsKey(option) == true)
{
var cmdCode = Settings.OptionDict[option];
reply = new TelnetCommand(cmdCode, this.Subject.Value);
}
else
{
reply = new TelnetCommand(CommandCode.WONT, this.Subject.Value);
}
return(reply);
}
private static int ProcessTerminalTypeStatement(
TerminalTypeCommand Stmt, ByteArrayBuilder WriteStream,
NegotiateSettings NegotiateSettings)
{
int sendStmtCx = 0;
if ((Stmt.SubOption != null) &&
(Stmt.SubOption.Value == TelnetOptionParm.SEND))
{
var ttSend =
new TerminalTypeCommand(Enums.CommandCode.SB, TelnetOptionParm.IS);
ttSend.AssignTerminalName(NegotiateSettings.TerminalType);
ttSend.GotClosingSE = true;
WriteStream.Append(ttSend.ToBytes());
}
return(sendStmtCx);
}
private void TelnetPrinterConnect(string ServerName)
{
var host = ServerName;
int port = 23;
SessionSettings sessionSettings = null;
// already connected.
if (this.ConnectPack?.IsConnected() == true)
{
MessageBox.Show("already connected to telnet server.");
return;
}
MainWindow.LogFile.ClearFile();
var negSettings = NegotiateSettings.Build5250Settings(
"SRICHTER", "STEVE41P", "IBM-3812-1");
// var negSettings = NegotiateSettings.Build5250Settings(
// "SRICHTER", "STEVE42P", "IBM-5256-1");
// connect to the server.
var rv = ConnectToServer_StartServerThreads(ServerName, port);
this.ConnectPack = rv.Item1;
sessionSettings = rv.Item2;
if (this.ConnectPack.IsConnected() == true)
{
// send message to connect thread. This will run telnet device startup
// processing on a backround thread. This way problems do not lock up
// the UI.
{
var startupMessage = new TelnetStartupMessage(
this.TelnetQueue,
this.ConnectPack, negSettings, this, MainWindow_TelnetStartupComplete,
TypeTelnetDevice.Printer);
this.ConnectThread.PostInputMessage(startupMessage);
}
}
}
private void MenuItem_Click(object sender, RoutedEventArgs e)
{
string itemText = null;
if (sender is MenuItem)
{
itemText = (sender as MenuItem).Header as string;
}
if (itemText == "Test")
{
var logList = new TelnetLogList();
var negSettings = NegotiateSettings.Build5250Settings("SRICHTER", "Steve25");
var lines = System.IO.File.ReadAllLines("c:\\downloads\\hextext.txt");
var ba = ParseHexLines(lines);
// print the bytes of the response stream as lines of hex text.
{
var rep = ba.ToHexReport(16);
logList.AddItem(Direction.Read, "Length:" + ba.Length + " Byte stream bytes:");
logList.AddItems(Direction.Read, rep);
}
var inputArray = new NetworkStreamBackedInputByteArray(ba, ba.Length);
var sessionSettings = new SessionSettings();
var rv = Process5250.GetAndParseWorkstationCommandList(
inputArray, sessionSettings);
logList.AddItems(rv.Item2);
var wrkstnCmdList = rv.Item1;
// draw the fields and literals on the canvas.
if (wrkstnCmdList != null)
{
foreach (var workstationCmd in wrkstnCmdList)
{
}
}
foreach (var item in logList)
{
this.Model.RunLog.Add(item.Text);
}
return;
}
else if (itemText == "Parse server stream")
{
var text = TextBox1.Text;
var lines = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
var ba = ParseHexLines(lines);
// print the bytes of the response stream as lines of hex text.
{
TelnetLogList logList = new TelnetLogList();
var rep = ba.ToHexReport(16);
logList.AddItem(Direction.Read, "Length:" + ba.Length + " Byte stream bytes:");
logList.AddItems(Direction.Read, rep);
}
}
else if (itemText == "Parse response stream")
{
var logList = new TelnetLogList();
var negSettings = NegotiateSettings.Build5250Settings("SRICHTER", "Steve25");
var lines = System.IO.File.ReadAllLines("c:\\downloads\\hextext.txt");
var ba = ParseHexLines(lines);
// print the bytes of the response stream as lines of hex text.
{
var rep = ba.ToHexReport(16);
logList.AddItem(Direction.Read, "Length:" + ba.Length + " Byte stream bytes:");
logList.AddItems(Direction.Read, rep);
}
Process5250.ParseResponseStream(logList, ba);
foreach (var item in logList)
{
if (item.NewGroup == true)
{
this.Model.RunLog.Add("");
}
this.Model.RunLog.Add(item.Text);
}
return;
}
else if (itemText == "Exit")
{
this.Close();
}
else if (itemText == "Settings")
{
}
else if (itemText == "Print")
{
LinePrinter.PrintLines(this.Model.RunLog);
}
else if (itemText == "Clear log")
{
Model.RunLog.Clear();
}
}
public static Tuple <int, int, List <ShowItemBase>, TelnetLogList> GetAndProcessStream(
TcpClient Client, NetworkStream NetStream,
NetworkStreamBackedInputByteArray InputArray,
NegotiateSettings NegotiateSettings,
bool ForceRead = false)
{
int sendStmtCx = 0;
int getStmtCx = 0;
var logList = new TelnetLogList();
var showItemList = new ShowItemList();
bool exitLoop = false;
while (exitLoop == false)
{
// read available bytes from input stream.
if (InputArray.IsEof())
{
var log = InputArray.ReadFromNetworkStream(5, 5, ForceRead);
logList.AddItems(log);
}
// no input data to process.
if (InputArray.IsEof())
{
break;
}
DataStreamHeader currentDataStreamHeader = null;
while (true)
{
if (InputArray.IsEof() == true)
{
break;
}
// process the input as 5250 data stream commands.
if (currentDataStreamHeader != null)
{
var rv = ParseAndProcessWorkstationCommand(InputArray, currentDataStreamHeader);
var workstationCommand = rv.Item1;
showItemList = rv.Item2;
currentDataStreamHeader = rv.Item3;
logList.AddItems(rv.Item4);
continue;
}
// peek and process input bytes as a telnet stmt. ( starts with IAC )
var telCmd = InputArray.NextTelnetCommand();
if (telCmd != null)
{
getStmtCx += 1;
var rv = TelnetConnection.ProcessTelnetCommand(telCmd, NegotiateSettings);
var cx = rv.Item1;
var writeBytes = rv.Item2;
logList.AddItems(rv.Item3);
sendStmtCx += cx;
WriteToHost(logList, writeBytes, NetStream);
continue;
}
var dsh = new DataStreamHeader(InputArray);
if ((dsh != null) && (dsh.Errmsg == null))
{
logList.AddItem(Direction.Read, dsh.ToString());
currentDataStreamHeader = dsh;
continue;
}
exitLoop = true;
break;
}
}
return(new Tuple <int, int, List <ShowItemBase>, TelnetLogList>(
getStmtCx, sendStmtCx, showItemList, logList));
}
