private void InternalRunActions(IEnumerable <SshShellAction> actions) { foreach (var expectAction in actions) { _shellStream.Expect(expectAction); } }
private static string command(string cmd, Regex terminator, Regex readyTerminator = null) { if (readyTerminator != null) { Console.Write(sshStream.Expect(readyTerminator)); } sshStream.WriteLine(cmd); if (terminator == null) { return(null); } string output = sshStream.Expect(terminator); Console.Write(output); var s = output.IndexOf('\n'); var e = output.LastIndexOf('\n'); output = output.Substring(s + 1, e - s); return(output); }
private static bool Initialize(Computer cpu) { try { sshClient = new SshClient(cpu.IP, 22, cpu.Username, cpu.Password); sshClient.Connect(); IDictionary <Renci.SshNet.Common.TerminalModes, uint> termkvp = new Dictionary <Renci.SshNet.Common.TerminalModes, uint> { { Renci.SshNet.Common.TerminalModes.ECHO, 53 } }; shellStream = sshClient.CreateShellStream("Recorder", 200, 50, 800, 600, 1024, termkvp); // Login As Root string feedback = shellStream.Expect(new Regex(@"[$>]")); shellStream.WriteLine("sudo su"); //expect password or user prompt feedback = shellStream.Expect(new Regex(@"([$#>:])")); if (feedback.Contains(":")) { shellStream.WriteLine(cpu.Password); //expect user or root prompt feedback = shellStream.Expect(new Regex(@"[$#>]")); return(true); } return(false); } catch (Exception) { return(false); } }
public static string TerminalExecute(string cmd, string password) { IDictionary <Renci.SshNet.Common.TerminalModes, uint> modes = new Dictionary <Renci.SshNet.Common.TerminalModes, uint>(); modes.Add(Renci.SshNet.Common.TerminalModes.ECHO, 53); ShellStream shellStream = client.CreateShellStream("xterm", 280, 24, 800, 600, 1024, modes); var output = shellStream.Expect(new Regex(@"[$>]")); log.Info(string.Format("Execution Reply: \t{0}", output)); log.Info(string.Format("Sending Text :{0}", cmd)); shellStream.WriteLine(cmd); output = shellStream.Expect(new Regex(@"([$#>:])")); log.Info(string.Format("Execution Reply: \t{0}", output)); log.Info(string.Format("Sending Text:{0}", password)); shellStream.WriteLine(password); output = shellStream.Expect(new Regex(@"([$#>:])")); log.Info(string.Format("Execution Reply: \t{0}", output)); output = shellStream.Read(); log.Info(string.Format("End Execution Reply: \t{0}", output)); return(output); }
private string WaitForPrompt(ShellStream stream, bool timeOut) { string result = ""; if (timeOut) { stream.Expect(TimeSpan.FromSeconds(5), new Renci.SshNet.ExpectAction("#", (output) => { result = output; })); } else { stream.Expect(new Renci.SshNet.ExpectAction("#", (output) => { result = output; })); } if (_verbose && _console != null) { _console.Log.Write(result); } return(result); }
private void Button_Sign_Up_Click(object sender, RoutedEventArgs e) { if (TextBox_Username.Text.Length == 0) { MessageBox.Show(Strings.LOGIN_IS_EMPTY, Strings.ERR_MSG); } else if (PasswordBox_Password.Password.Length == 0) { MessageBox.Show(Strings.PSW_IS_EMPTY, Strings.ERR_MSG); } else { SshClient client = new SshClient(Settings.HOST, 22, Settings.NAME, Settings.KEY); client.Connect(); IDictionary <Renci.SshNet.Common.TerminalModes, uint> modes = new Dictionary <Renci.SshNet.Common.TerminalModes, uint>(); modes.Add(Renci.SshNet.Common.TerminalModes.ECHO, 53); ShellStream shellStream = client.CreateShellStream("xterm", 80, 24, 800, 600, 1024, modes); var output = shellStream.Expect(new Regex(@"[$>]")); shellStream.WriteLine($"{Settings.RUN_REG_SCRIPT} {TextBox_Username.Text} {PasswordBox_Password.Password}"); output = shellStream.Expect(new Regex(@"([$#>:])")); shellStream.WriteLine(Settings.KEY); output = shellStream.Expect(new Regex(@"([$#>:])")); client.Disconnect(); MessageBox.Show(Strings.REG_SUCCESS, Strings.NOTIFICATION); } }
private void Button_Backup_Click(object sender, RoutedEventArgs e) { SshClient client = new SshClient(Settings.HOST, 22, Settings.NAME, Settings.KEY); client.Connect(); IDictionary <Renci.SshNet.Common.TerminalModes, uint> modes = new Dictionary <Renci.SshNet.Common.TerminalModes, uint>(); modes.Add(Renci.SshNet.Common.TerminalModes.ECHO, 53); ShellStream shellStream = client.CreateShellStream("xterm", 80, 24, 800, 600, 1024, modes); var output = shellStream.Expect(new Regex(@"[$>]")); Console.WriteLine("O: " + output); shellStream.WriteLine($"sudo sh backup.sh {sftpClient.ConnectionInfo.Username}"); output = shellStream.Expect(new Regex(@"([$#>:])")); Console.WriteLine("O: " + output); shellStream.WriteLine(Settings.KEY); output = shellStream.Expect(new Regex(@"([$#>:])")); Console.WriteLine("O: " + output); if (CheckBox_Backup_Server.IsChecked == true) { System.Windows.MessageBox.Show(Strings.BACKUP_SERVER_SUCCESS, Strings.NOTIFICATION); } if (CheckBox_Backup_Client.IsChecked == true) { try { FolderBrowserDialog dlg = new FolderBrowserDialog(); DialogResult result = dlg.ShowDialog(); if (result == System.Windows.Forms.DialogResult.OK) { string downloadPath = dlg.SelectedPath + @"\"; string selectedFile = Settings.BACKUP_FILENAME; using (var uplfileStream = System.IO.File.Create(downloadPath + selectedFile)) { sftpClient.DownloadFile("." + selectedFile, uplfileStream); } } } catch (NullReferenceException) { System.Windows.MessageBox.Show(Strings.NO_FILE_SELECTED_DOWNLOAD, Strings.NO_FILE_SELECTED); } } client.Disconnect(); Close(); }
public void ExpectSSH(string address, string login, string password, string command) { try { SshClient sshClient = new SshClient(address, 22, login, password); sshClient.Connect(); IDictionary <Renci.SshNet.Common.TerminalModes, uint> termkvp = new Dictionary <Renci.SshNet.Common.TerminalModes, uint>(); termkvp.Add(Renci.SshNet.Common.TerminalModes.ECHO, 53); ShellStream shellStream = sshClient.CreateShellStream("xterm", 80, 24, 800, 600, 1024, termkvp); //login string rep = shellStream.Expect(new Regex(@"[$]")); Output(rep, true); Thread.Sleep(1000); //root shellStream.WriteLine("su -"); rep = shellStream.Expect(new Regex(@"[:]")); shellStream.WriteLine("prodan46"); Output(rep, true); rep = shellStream.Expect(new Regex(@"([#])")); Output(rep, true); Thread.Sleep(100); //comando shellStream.WriteLine(command); rep = shellStream.Expect(new Regex(@"([#])")); Output(rep + Environment.NewLine + Environment.NewLine, true); shellStream.WriteLine("/etc/rc.d/rc.postgres status"); rep = shellStream.Expect(new Regex(@"([#])")); Output(rep + Environment.NewLine + Environment.NewLine + Environment.NewLine, true); //if (rep.Contains(":")) //{ // shellStream.WriteLine("prodan46"); // rep = shellStream.Expect(new Regex(@"[$#>]")); // Output(rep, true); //} sshClient.Disconnect(); } catch (Exception ex) { System.Console.WriteLine(ex.ToString()); throw ex; } }
/// <summary> /// Executes an asynchronous command /// </summary> /// <param name="csentry">The CSEntryChange to apply to this command</param> /// <param name="result">The result object for the current operation</param> /// <param name="command">The definition of the command to execute</param> private static void ExecuteAsyncCommand(CSEntryChange csentry, OperationResult result, AsyncCommand command) { string output = string.Empty; try { ShellStream shell = client.CreateShellStream("lithnet.sshma", 80, 24, 800, 600, 1024); output += shell.ReadLine(); foreach (AsyncCommandSend sendCommand in command.Commands) { if (sendCommand is AsyncCommandSendExpect) { AsyncCommandSendExpect expectCommand = sendCommand as AsyncCommandSendExpect; string expectText = expectCommand.Expect.ExpandDeclaration(csentry, false, false); TimeSpan timeout = new TimeSpan(0, 0, expectCommand.Timeout); shell.Expect( timeout, new ExpectAction( expectText, (s) => { System.Diagnostics.Debug.WriteLine(s); output += s; shell.Write(expectCommand.Command.ExpandDeclaration(csentry, false, false) + "\n"); })); } else { shell.Write(sendCommand.Command.ExpandDeclaration(csentry, false, false) + "\n"); } } if (command.ExpectSuccess != null) { if (!string.IsNullOrWhiteSpace(command.ExpectSuccess.Expect.DeclarationText)) { TimeSpan timeout = new TimeSpan(0, 0, command.ExpectSuccess.Timeout); if (shell.Expect(command.ExpectSuccess.Expect.ExpandDeclaration(csentry, false, false), timeout) == null) { throw new ExtensibleExtensionException("The asynchronous command did not return the expected result"); } } } } finally { Logger.WriteLine("Shell session log:", LogLevel.Debug); Logger.WriteLine(output, LogLevel.Debug); } }
private void ExperimentalSudo(SynoReportViaSSH session, string command) { try { using (SshClient sshClient = new SshClient(session.ConnectionInfo)) { sshClient.Connect(); IDictionary <TerminalModes, uint> termkvp = new Dictionary <TerminalModes, uint> { { TerminalModes.ECHO, 53 } }; ShellStream shellStream = sshClient.CreateShellStream("xterm", 80, 24, 800, 600, 1024, termkvp); //Get logged in string rep = shellStream.Expect(new Regex(@"[$>]")); //expect user prompt //this.writeOutput(results, rep); // //send command shellStream.WriteLine("sudo " + command); rep = shellStream.Expect(new Regex(@"([$#>:])")); //expect password or user prompt //this.writeOutput(results, rep); //check to send password if (rep.Contains(":")) { //send password shellStream.WriteLine(session.Password); rep = shellStream.Expect(new Regex(@"[$#>]"), new TimeSpan(0, 0, 10)); //expect user or root prompt //this.writeOutput(results, rep); if (rep == null) { System.Diagnostics.Debug.WriteLine("sudo action failed?"); } else { System.Diagnostics.Debug.WriteLine("{0}\r\n{1}", command, rep); } } sshClient.Disconnect(); } }//try to open connection catch (Exception ex) { System.Console.WriteLine(ex.ToString()); throw; } }
private void processShellStream(ShellStream shellStream, String expectedRegexPattern, StreamWriter writer, string input, bool isOptional, ICollection <string> messages) { bool wasExecuted = false; Action <string> action = (x) => { if (writer != null && input != null) { writer.WriteLine(input); } ; wasExecuted = true; messages.Clear(); }; var expectAction = new ExpectAction(new Regex(expectedRegexPattern, RegexOptions.IgnoreCase), action); shellStream.Expect(TimeSpan.FromSeconds(Timeout), expectAction); // Shell output is always null when the action was not executed. if (!(isOptional || wasExecuted)) { var message = messages.LastOrDefault(); if (messages.Count > 1) { message = string.Format("{0} / {1}", messages.First(), messages.Last()); } throw new Exception(String.Format("Error changing password. Got '{0}' from shell which didn't match the expected '{1}' regex pattern.", message, expectedRegexPattern)); } }
private string RunShellCommand(ShellStream Stream, string CommandLine, bool ExpectRootPrompt) { System.Console.Out.WriteLine("CL$ " + CommandLine); Stream.WriteLine(CommandLine); string Response = ""; bool End = false; while (!End) { Stream.Expect( new ExpectAction(new Regex(@"\w+@\w+\:[\w~\/\\]+\$"), (Input) => { End = true; Response += Input; }), new ExpectAction(new Regex(@"\w+@\w+\:[\w~\/\\]+#"), (Input) => { End = true; Response += Input; }), new ExpectAction(new Regex(@"\n\:"), (Input) => { Response += Input; Stream.Write(" "); }) ); } System.Console.Out.WriteLine(Response); return(Response); }
public IEnumerable <string> ExecuteCommand(string command) { lock (_lock) { if (!Connected) { Connect(); if (!Connected) { return(null); } } //Split Write and WriteLine as it looked like WriteLine was truncating commands _shellStream.Write(command); _shellStream.WriteLine(""); string streamOutput = _shellStream.Expect(new Regex(_terminalPrompt)); Debug.Assert(!string.IsNullOrEmpty(streamOutput)); using (StringReader sr = new StringReader(streamOutput)) { var result = new List <string>(); string line; while ((line = sr.ReadLine()) != null) { result.Add(line); } return(result); } } }
public async Task SSHWriteLine(string text) { try { _shellStream.WriteLine(text); } catch (Exception e) { Logger.WriteLine(10, e.ToString()); try { _shellStream.Dispose(); } catch { } if (!_client.IsConnected) { _client.Connect(); } try { _shellStream = _client.CreateShellStream("sync - unzip", 80, 120, 640, 480, short.MaxValue); } catch { _client.Disconnect(); _client.Connect(); _shellStream = _client.CreateShellStream("sync - unzip", 80, 120, 640, 480, short.MaxValue); } _shellStream.Expect(newLineRegex, TimeSpan.FromSeconds(SSHTimeout)); _shellStream.WriteLine(text); } }
public string exec(string cmdline) { shellStream.WriteLine(cmdline); var rep = shellStream.Expect(new Regex(@"[$#]")); pn(rep); return(rep); }
private void InstallAgentAndOnboard(SshClient sshClient, ref ServerListItem server) { string installcmd = server.Architecture == ServerArchitecture.x64 ? "sh /home/" + server.Username + "/" + x64Agent + " --install -w " + txtWorkspaceId.Text + " -s " + txtSharedKey.Text + "\n": "sh /home/" + server.Username + "/" + x86Agent + " --install -w " + txtWorkspaceId.Text + " -s " + txtSharedKey.Text + "\n"; IDictionary <Renci.SshNet.Common.TerminalModes, uint> termkvp = new Dictionary <Renci.SshNet.Common.TerminalModes, uint> { { Renci.SshNet.Common.TerminalModes.ECHO, 53 } }; ShellStream shell = sshClient.CreateShellStream("xterm", 800, 240, 1024, 720, 1024, termkvp); //ShellStream shell = sshClient.CreateShellStream("Tail", 0, 0, 0, 0, 1024); StreamWriter wr = new StreamWriter(shell); StreamReader rd = new StreamReader(shell); wr.AutoFlush = true; wr.WriteLine("su"); string rep = shell.Expect(new Regex(@"([$#>:])"), new TimeSpan(0, 0, 3)); //expect password or user prompt //check to send password if (rep.EndsWith("Password: "******"[$#>]"), new TimeSpan(0, 0, 3)); server.Log += rep; var cmd = sshClient.CreateCommand(installcmd); var result = cmd.BeginExecute(); using (var reader = new StreamReader(cmd.OutputStream, Encoding.UTF8, true, 1024, true)) { while (!result.IsCompleted || !reader.EndOfStream) { string line = reader.ReadLine(); if (line != null) { server.Log += line; } } } } }
public override TaskStatus Run() { Info("Running SSH command..."); var success = true; ShellStream stream = null; try { var connectionInfo = new ConnectionInfo(Host, Port, Username, new PasswordAuthenticationMethod(Username, Password)); SshClient sshclient = new SshClient(connectionInfo); sshclient.Connect(); var modes = new Dictionary <TerminalModes, uint> { { TerminalModes.ECHO, 53 } }; stream = sshclient.CreateShellStream("xterm", 80, 24, 800, 600, 4096, modes); var result = stream.Expect(Prompt, ExpectTimeout); if (result == null) { Error($"Timeout {Timeout} seconds reached while connecting."); return(new TaskStatus(WorkflowStatus.Error)); } foreach (var line in result.GetLines()) { Info(line); } SendCommand(stream, Cmd); } catch (ThreadAbortException) { throw; } catch (Exception e) { Logger.ErrorFormat("Error while running SSH command: {0}\n", e.Message); success = false; } finally { if (stream != null) { stream.Close(); } } var status = WorkflowStatus.Success; if (!success) { status = WorkflowStatus.Error; } Info("Task finished."); return(new TaskStatus(status)); }
public static bool Reload(Computer cpu, string bcIP, int bcPort, string path) { if (Initialize(cpu)) { string command = String.Format("./gaf.sh {0} {1} {2} &", bcIP, bcPort, path); shellStream.WriteLine(command); #if (DEBUG) string feedback = shellStream.Expect("root", new TimeSpan(0, 0, 10)); #endif sshClient.Disconnect(); return(true); } else { return(false); } }
public static bool Start(Computer cpu, RecordFile cfile, InterceptorType type, bool rmCfile, string bcIP, int bcPort, string path) { if (Initialize(cpu)) { string command = String.Format("cd dev_utilities && ./interceptor.sh -r {0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} &", type.ToString(), cfile.ID, cfile.Count, cfile.Band, cfile.ARFCN, cfile.Frequency, cfile.SampleRate, cfile.Rx, rmCfile ? 1 : 0, bcIP, bcPort, path); shellStream.WriteLine(command); #if (DEBUG) string feedback = shellStream.Expect("root", new TimeSpan(0, 0, 10)); #endif sshClient.Disconnect(); return(true); } else { return(false); } }
/// <summary> /// Start The Scanner /// </summary> /// <param name="cpu">CPU</param> /// <param name="indx">Receiver index</param> /// <param name="ip">Broadcast IP</param> /// <param name="port">Broadcast port</param> /// <param name="band">Band</param> /// <param name="gain">Gain</param> /// <param name="speed">Speed</param> /// <param name="sample_rate">Sample Rate</param> /// <param name="ppm">PPM</param> /// <returns></returns> public static bool Start(Computer cpu, int indx, string ip, int port, string band, int gain, int speed, int sample_rate, int ppm) { if (Initialize(cpu)) { string command = String.Format("cd dev_utilities && ./scanner.sh -r {0} {1} {2} {3} {4} {5} {6} {7} &", indx, band, sample_rate, ppm, gain, speed, ip, port); shellStream.WriteLine(command); #if (DEBUG) string feedback = shellStream.Expect("root", new TimeSpan(0, 10, 0)); #endif sshClient.Disconnect(); return(true); } else { return(false); } }
/// <summary> /// /// </summary> /// <param name="password"></param> /// <param name="stream"></param> private void SwithToRoot(string password, ShellStream stream) { var prompt = stream.Expect(new Regex(@"[$>]")); _log.Information(prompt); stream.WriteLine("sudo su"); prompt = stream.Expect(new Regex(@"([$#>:])")); _log.Information(prompt); if (!prompt.Contains(":")) { return; } stream.WriteLine(password); prompt = stream.Expect(new Regex(@"[$#>]")); _log.Information(prompt); }
public static bool Start(Computer cpu, int indx, string band, int arfcn, double freq, int gain, int sr, int td, int nr, int mood, string path) { if (Initialize(cpu)) { string command = String.Format("cd dev_utilities && ./receiver.sh -r {0} {1} {2} {3} {4} {5} {6} {7} {8} {9} &", indx, band, arfcn, freq, gain, sr, td, nr, mood, path); shellStream.WriteLine(command); #if (DEBUG) string feedback = shellStream.Expect("root", new TimeSpan(0, 0, 10)); #endif sshClient.Disconnect(); return(true); } else { return(false); } }
public bool ShellExecute(string command, TimeSpan?timespan = null) { if (!StartShellStream()) { return(false); } shellStream.WriteLine(command); return(timespan == null || shellStream.Expect(command, timespan.Value) != null); }
private bool GetExpect(ShellStream shell, string expect) { var exp = shell.Expect(expect, TimeSpan.FromSeconds(60)); if (!string.IsNullOrEmpty(exp)) { return(true); } LogTimeout(expect); return(false); }
public void updatePath() { try { stream.WriteLine("pwd"); stream.Expect("pwd"); String result = stream.ReadLine(TimeSpan.FromMilliseconds(500)); while (result == "") { result = stream.ReadLine(TimeSpan.FromMilliseconds(500)); } Globals.mainForm.setTerminalPathText(result); Globals.mainForm.setReomtePath(result); Globals.mainForm.clearServers(); stream.WriteLine("ls -1ad */ 2>/dev/null"); stream.Expect("ls -1ad */ 2>/dev/null"); result = stream.ReadLine(TimeSpan.FromMilliseconds(500)); while (result != null) { result = stream.ReadLine(TimeSpan.FromMilliseconds(500)); if (result != null) { Globals.mainForm.addServerFolderPath(result); } } Globals.mainForm.addServerFolderFile("."); Globals.mainForm.addServerFolderFile(".."); stream.WriteLine("ls -p | grep -v / 2>/dev/null"); stream.Expect("ls -p | grep -v / 2>/dev/null"); result = stream.ReadLine(TimeSpan.FromMilliseconds(500)); while (result != null) { result = stream.ReadLine(TimeSpan.FromMilliseconds(500)); Globals.mainForm.addServerFolderFile(result); } } catch (Exception e1) { } }
public string ExecuteShellCommand(string[] CommandList, string EndOfCommand) { int i = 0; while (i < CommandList.Length) { WriteStream.WriteLine(CommandList[i]); i++; } WriteStream.WriteLine(EndOfCommand); return(shell.Expect(EndOfCommand, new TimeSpan(0, 0, 10))); }
private bool GetExpect(ShellStream shell, Regex expect) { var exp = shell.Expect(expect, TimeSpan.FromSeconds(60)); if (string.IsNullOrEmpty(exp)) { LogTimeout(exp); return(false); } _log.Information(exp); return(true); }
public static void SwithToRoot(string password, ShellStream stream) { // Get logged in and get user prompt string prompt = stream.Expect(new Regex(@"[$>]")); //Console.WriteLine(prompt); // Send command and expect password or user prompt stream.WriteLine("su - root"); prompt = stream.Expect(new Regex(@"([$#>:])")); //Console.WriteLine(prompt); // Check to send password if (prompt.Contains(":")) { // Send password stream.WriteLine(password); prompt = stream.Expect(new Regex(@"[$#>]")); //Console.WriteLine(prompt); } }
private void WaitForPrompt(ShellStream stream, bool timeOut) { if (_verbose) { if (timeOut) { stream.Expect(TimeSpan.FromSeconds(5), new Renci.SshNet.ExpectAction("#", (output) => { if (_console != null) { _console.Log.Write(output); } })); } else { stream.Expect(new Renci.SshNet.ExpectAction("#", (output) => { if (_console != null) { _console.Log.Write(output); } })); } } else { if (timeOut) { stream.Expect("#", TimeSpan.FromSeconds(5)); } else { stream.Expect("#"); } } }
public String expect(String cmd, int t) { String retval = ""; try { stream.Write(cmd + "\r"); stream.Flush(); Thread.Sleep(t); retval = stream.Expect(reg_prompt, waitTime); stream.Flush(); while (stream.DataAvailable == true) { retval += stream.Read(); } return(retval); } catch (System.Exception e) { return(retval + "\n" + "err: " + e.ToString()); } }
public void ExpectTest3() { Session session = null; // TODO: Initialize to an appropriate value string terminalName = string.Empty; // TODO: Initialize to an appropriate value uint columns = 0; // TODO: Initialize to an appropriate value uint rows = 0; // TODO: Initialize to an appropriate value uint width = 0; // TODO: Initialize to an appropriate value uint height = 0; // TODO: Initialize to an appropriate value int maxLines = 0; // TODO: Initialize to an appropriate value IDictionary<TerminalModes, uint> terminalModeValues = null; // TODO: Initialize to an appropriate value ShellStream target = new ShellStream(session, terminalName, columns, rows, width, height, maxLines, terminalModeValues); // TODO: Initialize to an appropriate value string text = string.Empty; // TODO: Initialize to an appropriate value string expected = string.Empty; // TODO: Initialize to an appropriate value string actual; actual = target.Expect(text); Assert.AreEqual(expected, actual); Assert.Inconclusive("Verify the correctness of this test method."); }
public void ExpectTest5() { Session session = null; // TODO: Initialize to an appropriate value string terminalName = string.Empty; // TODO: Initialize to an appropriate value uint columns = 0; // TODO: Initialize to an appropriate value uint rows = 0; // TODO: Initialize to an appropriate value uint width = 0; // TODO: Initialize to an appropriate value uint height = 0; // TODO: Initialize to an appropriate value int maxLines = 0; // TODO: Initialize to an appropriate value IDictionary<TerminalModes, uint> terminalModeValues = null; // TODO: Initialize to an appropriate value ShellStream target = new ShellStream(session, terminalName, columns, rows, width, height, maxLines, terminalModeValues); // TODO: Initialize to an appropriate value TimeSpan timeout = new TimeSpan(); // TODO: Initialize to an appropriate value ExpectAction[] expectActions = null; // TODO: Initialize to an appropriate value target.Expect(timeout, expectActions); Assert.Inconclusive("A method that does not return a value cannot be verified."); }