public void Test_Execute_Command_Asynchronously_With_Callback()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var callbackCalled = false;
var cmd = client.CreateCommand("sleep 5s; echo 'test'");
var asyncResult = cmd.BeginExecute(new AsyncCallback((s) =>
{
callbackCalled = true;
}), null);
while (!asyncResult.IsCompleted)
{
Thread.Sleep(100);
}
cmd.EndExecute(asyncResult);
Assert.IsTrue(callbackCalled);
client.Disconnect();
}
}
public void BeginExecuteTest()
{
string expected = "123\n";
string result;
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
#region Example SshCommand CreateCommand BeginExecute IsCompleted EndExecute
client.Connect();
var cmd = client.CreateCommand("sleep 15s;echo 123"); // Perform long running task
var asynch = cmd.BeginExecute();
while (!asynch.IsCompleted)
{
// Waiting for command to complete...
Thread.Sleep(2000);
}
result = cmd.EndExecute(asynch);
client.Disconnect();
#endregion
Assert.IsNotNull(asynch);
Assert.AreEqual(expected, result);
}
}
public void Test_EndExecute_Before_BeginExecute()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var cmd = client.CreateCommand("ls -l");
cmd.EndExecute(null);
client.Disconnect();
}
}
public void CreateCommandTest1()
{
ConnectionInfo connectionInfo = null; // TODO: Initialize to an appropriate value
SshClient target = new SshClient(connectionInfo); // TODO: Initialize to an appropriate value
string commandText = string.Empty; // TODO: Initialize to an appropriate value
SshCommand expected = null; // TODO: Initialize to an appropriate value
SshCommand actual;
actual = target.CreateCommand(commandText);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public void Test_Execute_Command_Asynchronously_With_Callback_On_Different_Thread()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var currentThreadId = Thread.CurrentThread.ManagedThreadId;
int callbackThreadId = 0;
var cmd = client.CreateCommand("sleep 5s; echo 'test'");
var asyncResult = cmd.BeginExecute(new AsyncCallback((s) =>
{
callbackThreadId = Thread.CurrentThread.ManagedThreadId;
}), null);
while (!asyncResult.IsCompleted)
{
Thread.Sleep(100);
}
cmd.EndExecute(asyncResult);
Assert.AreNotEqual(currentThreadId, callbackThreadId);
client.Disconnect();
}
}
public void Test_Execute_Command_Asynchronously()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var cmd = client.CreateCommand("sleep 5s; echo 'test'");
var asyncResult = cmd.BeginExecute(null, null);
while (!asyncResult.IsCompleted)
{
Thread.Sleep(100);
}
cmd.EndExecute(asyncResult);
Assert.IsTrue(cmd.Result == "test\n");
client.Disconnect();
}
}
public void Test_Execute_SingleCommand()
{
var host = Resources.HOST;
var username = Resources.USERNAME;
var password = Resources.PASSWORD;
using (var client = new SshClient(host, username, password))
{
#region Example SshCommand CreateCommand Execute
client.Connect();
var testValue = Guid.NewGuid().ToString();
var command = string.Format("echo {0}", testValue);
var cmd = client.CreateCommand(command);
var result = cmd.Execute();
result = result.Substring(0, result.Length - 1); // Remove \n character returned by command
client.Disconnect();
#endregion
Assert.IsTrue(result.Equals(testValue));
}
}
public void Test_PortForwarding_Remote()
{
// ******************************************************************
// ************* Tests are still in not finished ********************
// ******************************************************************
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var port1 = new ForwardedPortRemote(8082, "www.renci.org", 80);
client.AddForwardedPort(port1);
port1.Exception += delegate(object sender, ExceptionEventArgs e)
{
Assert.Fail(e.Exception.ToString());
};
port1.Start();
var boundport = port1.BoundPort;
System.Threading.Tasks.Parallel.For(0, 5,
//new ParallelOptions
//{
// MaxDegreeOfParallelism = 1,
//},
(counter) =>
{
var cmd = client.CreateCommand(string.Format("wget -O- http://localhost:{0}", boundport));
var result = cmd.Execute();
var end = DateTime.Now;
Debug.WriteLine(string.Format("Length: {0}", result.Length));
}
);
Thread.Sleep(1000 * 100);
port1.Stop();
}
}
public static string GetKernel(SshClient sshClient) => sshClient.CreateCommand("sudo freebsd-version -k").Execute();
public void Test_Execute_Command_Asynchronously_With_Error()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var cmd = client.CreateCommand("sleep 5s; ;");
var asyncResult = cmd.BeginExecute(null, null);
while (!asyncResult.IsCompleted)
{
Thread.Sleep(100);
}
cmd.EndExecute(asyncResult);
Assert.IsFalse(string.IsNullOrEmpty(cmd.Error));
client.Disconnect();
}
}
/// <summary>
/// Perform some kind of control action
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
public override bool Execute(SshClient client)
{
bool success = false;
var rxData = new StringBuilder();
SshCommand cmd = null;
try
{
if (string.IsNullOrEmpty(ErrorResponse) && string.IsNullOrEmpty(SuccessResponse))
{
throw new Exception("Need Error/Success response defined for StreamCommand");
}
Logger.Debug("Command Tx: " + Send);
cmd = client.CreateCommand(Send);
cmd.CommandTimeout = new TimeSpan(0, 0, TimeoutSecs);
cmd.BeginExecute(new AsyncCallback(ExecutionCallback), cmd);
var reader = new StreamReader(cmd.OutputStream);
DateTime dtStart = DateTime.Now;
long intervalS;
bool timedOut = false;
do
{
if (reader.BaseStream.Length > 0)
{
rxData.Append(reader.ReadToEnd());
}
if (rxData.Length > 0)
{
if (!string.IsNullOrEmpty(ErrorResponse))
{
if (rxData.ToString().Contains(ErrorResponse))
{
Logger.Warn("- Error response: " + rxData);
return(false);
}
}
if (!string.IsNullOrEmpty(SuccessResponse))
{
if (rxData.ToString().Contains(SuccessResponse))
{
Logger.Warn("- Success response: " + rxData);
success = true;
}
}
}
intervalS = (long)DateTime.Now.Subtract(dtStart).TotalSeconds;
if (TimeoutSecs > 0)
{
timedOut = intervalS > TimeoutSecs;
}
} while (!timedOut && !success);
if (timedOut)
{
UpdateUI("*** Timed out");
return(false);
}
// Perform regexp replacement...
Output = !string.IsNullOrEmpty(OutputRegExp) ? Regex.Match(rxData.ToString(), OutputRegExp).Value : rxData.ToString();
Logger.Debug("Output: " + (!string.IsNullOrEmpty(Output) ? Output : "<none>"));
}
catch (Exception ex)
{
Logger.Warn("Exception in worker thread: " + ex.Message);
success = false;
}
finally
{
try
{
// TODO: We seem to timeout and disconnect if we try to cancel. Perhaps better for now to kill the process in the next command instead
//cmd.CancelAsync();
cmd.Dispose();
cmd = null;
}
catch (Exception e)
{
Logger.Warn("Exception stopping shell: " + e.Message);
}
}
return(success);
}
public void Test_Execute_ExtendedOutputStream()
{
var host = Resources.HOST;
var username = Resources.USERNAME;
var password = Resources.PASSWORD;
using (var client = new SshClient(host, username, password))
{
#region Example SshCommand CreateCommand Execute ExtendedOutputStream
client.Connect();
var cmd = client.CreateCommand("echo 12345; echo 654321 >&2");
var result = cmd.Execute();
Console.Write(result);
var reader = new StreamReader(cmd.ExtendedOutputStream);
Console.WriteLine("DEBUG:");
Console.Write(reader.ReadToEnd());
client.Disconnect();
#endregion
Assert.Inconclusive();
}
}
private async Task <ConnectionResult> SShTunnel(RconServer server, AuthType type, string command)
{
ConnectionInfo connectionInfo = null;
var result = new ConnectionResult();
//auth
if (type == AuthType.PrivateKey)
{
var keyFiles = new[] { new PrivateKeyFile("KeyFiles/" + server.SshKeyFileName) };
connectionInfo = new ConnectionInfo(server.Adress, server.SshUsername,
new PrivateKeyAuthenticationMethod(server.SshUsername, keyFiles));
}
else if (type == AuthType.UserPass)
{
connectionInfo = new ConnectionInfo(server.Adress, server.SshUsername,
new PasswordAuthenticationMethod(server.SshUsername, server.SshPassword));
}
else if (type == AuthType.PrivateKeyPassphrase)
{
var keyFiles = new[] { new PrivateKeyFile("KeyFiles/" + server.SshKeyFileName, server.SshPassphrase) };
connectionInfo = new ConnectionInfo(server.Adress, server.SshUsername,
new PasswordAuthenticationMethod(server.SshUsername, server.SshPassphrase),
new PrivateKeyAuthenticationMethod(server.SshUsername, keyFiles));
}
var guid = Guid.NewGuid();
var tmpFolderRemote = "/tmp/pavlovNetcatRconWebServer/";
var pavlovLocalScriptPath = "Temp/pavlovNetcatRconWebServerScript" + guid + ".sh";
File.Copy("pavlovNetcatRconWebServerScript.sh", pavlovLocalScriptPath, true);
var pavlovRemoteScriptPath = tmpFolderRemote + "Script" + guid + ".sh";
var commandFilelocal = "Temp/Command" + guid;
File.Copy("Command", commandFilelocal, true);
var commandFileRemote = tmpFolderRemote + "Commands" + guid;
try
{
//connection
using var client = new SshClient(connectionInfo);
client.Connect();
//check if first scripts exist
using (var sftp = new SftpClient(connectionInfo))
{
try
{
sftp.Connect();
if (sftp.Exists(tmpFolderRemote))
{
var files = sftp.ListDirectory(tmpFolderRemote);
foreach (var file in files.Where(x => x.Name != "." && x.Name != ".."))
{
var chmodCommandFiles = client.CreateCommand("chmod 7777 " + pavlovRemoteScriptPath);
chmodCommandFiles.Execute();
sftp.DeleteFile(file.FullName);
}
var chmodCommandFolder = client.CreateCommand("chmod 7777 " + tmpFolderRemote);
chmodCommandFolder.Execute();
sftp.DeleteDirectory(tmpFolderRemote);
}
//sftp clear old files
sftp.CreateDirectory(tmpFolderRemote);
//That part means that it will not work if more than one requets happen?
string text = await File.ReadAllTextAsync(pavlovLocalScriptPath);
text = text.Replace("{port}", server.TelnetPort.ToString());
await File.WriteAllTextAsync(pavlovLocalScriptPath, text);
await File.WriteAllTextAsync(commandFilelocal,
server.Password + "\n" + command + "\n" + "Disconnect");
await using (var uplfileStream = File.OpenRead(pavlovLocalScriptPath))
{
sftp.UploadFile(uplfileStream, pavlovRemoteScriptPath, true);
}
await using (var uplfileStream = File.OpenRead(commandFilelocal))
{
sftp.UploadFile(uplfileStream, commandFileRemote, true);
}
File.Delete(commandFilelocal);
File.Delete(pavlovLocalScriptPath);
}
finally
{
sftp.Disconnect();
}
}
var sshCommand = client.CreateCommand("chmod +x " + pavlovRemoteScriptPath);
//var sshCommand = client.CreateCommand("telnet localhost " + server.TelnetPort);
sshCommand.Execute();
var sshCommandExecuteBtach = client.CreateCommand(pavlovRemoteScriptPath + " " + commandFileRemote);
sshCommandExecuteBtach.CommandTimeout = TimeSpan.FromMilliseconds(500);
try
{
sshCommandExecuteBtach.Execute();
}
catch (SshOperationTimeoutException)
{
if (!string.IsNullOrEmpty(sshCommandExecuteBtach.Error))
{
result.errors.Add(sshCommandExecuteBtach.Error);
}
}
if (!sshCommandExecuteBtach.Result.Contains("Password:"******"After the ssh connection the telnet connection gives strange answers. Can not send command!");
}
if (!sshCommandExecuteBtach.Result.Contains("Authenticated=1"))
{
result.errors.Add(
"After the ssh connection the telnet connection can not login. Can not send command!");
}
Task.Delay(500).Wait();
// check answer
result.answer = sshCommandExecuteBtach.Result;
if (result.errors.Count > 0 && result.answer == "")
{
return(result);
}
result.Seccuess = true;
if (result.answer.Contains("{"))
{
result.answer = result.answer.Substring(result.answer.IndexOf("{", StringComparison.Ordinal));
}
if (result.answer.StartsWith("Password: Authenticated=1"))
{
result.answer = result.answer.Replace("Password: Authenticated=1", "");
}
}
catch (Exception e)
{
switch (e)
{
case SshAuthenticationException _:
result.errors.Add("Could not Login over ssh!");
break;
case SshConnectionException _:
result.errors.Add("Could not connect to host over ssh!");
break;
case SshOperationTimeoutException _:
result.errors.Add("Could not connect to host cause of timeout over ssh!");
break;
case SocketException _:
result.errors.Add("Could not connect to host!");
break;
default:
throw;
}
return(result);
}
return(result);
}
public string GetHostname(SshClient sshClient) => sshClient.CreateCommand("hostname").Execute().Replace("\n", "");
/// <summary>
/// constructs the target ip for the mdf
/// login to ip through ssh and sends commands
/// </summary>
void FinishMDF()
{
//string ip = "10.146.3.39";
string ip = "10." + subnet + ".0.1";
using (var client = new SshClient(ip, userLogin, userPassword))
{
client.Connect();
if (client.IsConnected)
{
Console.WriteLine("connected");
}
SshCommand command = client.CreateCommand("config t");
command.Execute();
command = client.CreateCommand("int eth");
command.Execute();
command = client.CreateCommand("no dual");
command.Execute();
command = client.CreateCommand("inline power power-by-class 2");
command.Execute();
command = client.CreateCommand("vlan " + 10);
command.Execute();
command = client.CreateCommand("tag eth" + slotNum + "/" + portNum);
command.Execute();
command = client.CreateCommand("vlan 30");
command.Execute();
command = client.CreateCommand("tag eth" + slotNum + "/" + portNum);
command.Execute();
command = client.CreateCommand("vlan 40");
command.Execute();
command = client.CreateCommand("no tag eth" + slotNum + "/" + portNum);
command.Execute();
command = client.CreateCommand("vlan 50");
command.Execute();
command = client.CreateCommand("no tag eth" + slotNum + "/" + portNum);
command.Execute();
command = client.CreateCommand("int eth" + slotNum + "/" + portNum);
command.Execute();
command = client.CreateCommand("Dual 10");
command.Execute();
client.Disconnect();
}
}
public void Test_Get_Result_Without_Execution()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var cmd = client.CreateCommand("ls -l");
Assert.IsTrue(string.IsNullOrEmpty(cmd.Result));
client.Disconnect();
}
}
public ServerCommandResult ExecuteCommand(ServerCommand serverCommand)
{
if (!IsConnected)
{
throw new ServerConnectionException("Server connection is not established");
}
if (serverCommand == null)
{
throw new ArgumentNullException(nameof(serverCommand));
}
if (string.IsNullOrEmpty(serverCommand.Text))
{
throw new CommandNotSpecifiedException($"Command was not defined");
}
using (var command = Client.CreateCommand(serverCommand.Text))
{
if (serverCommand.Timeout.HasValue)
{
command.CommandTimeout = serverCommand.Timeout.Value;
}
Stopwatch stopwatch = Stopwatch.StartNew();
var result = new ServerCommandResult();
try
{
command.Execute();
}
catch (SshOperationTimeoutException exception)
{
if (serverCommand.ThrowError)
{
throw new CommandTimeoutException(exception.Message);
}
else
{
result.Error = exception.Message;
}
}
catch (SshConnectionException exception)
{
if (serverCommand.ThrowError)
{
throw new ServerConnectionException(exception.Message);
}
else
{
result.Error = exception.Message;
}
}
finally
{
if (stopwatch.IsRunning)
{
stopwatch.Stop();
}
}
result.Result = command.Result;
result.ElapsedTime = stopwatch.Elapsed;
result.Error = command.Error;
result.ExitStatus = command.ExitStatus;
if (serverCommand.ThrowError && !string.IsNullOrEmpty(command.Error))
{
if (result.Error.Contains("command not found"))
{
throw new CommandNotFoundException($"Command {command.CommandText} is not found");
}
throw new CommandResultException($"Command {command.CommandText} returned the following error: {command.Error}");
}
return(result);
}
}
/// <summary>
/// constructs the target ip for the mdf
/// login to ip through ssh and sends commands
/// </summary>
void FinishIDF()
{
string ip = "10." + subnet + "." + (idfNum * 8).ToString() + ".1";
using (var client = new SshClient(ip, userLogin, userPassword))
{
client.Connect();
if (client.IsConnected)
{
Console.WriteLine("connected");
}
SshCommand command = client.CreateCommand("config t");
command.Execute();
command = client.CreateCommand("int eth");
command.Execute();
command = client.CreateCommand("no dual");
command.Execute();
command = client.CreateCommand("inline power power-by-class 2");
command.Execute();
command = client.CreateCommand("vlan " + 10 + idfNum); // <-- switch to closet
command.Execute();
command = client.CreateCommand("tag eth" + idf_switchNum + "/" + idf_cableType + "/" + idf_portNum);
command.Execute();
command = client.CreateCommand("vlan 30");
command.Execute();
command = client.CreateCommand("tag eth" + idf_switchNum + "/" + idf_cableType + "/" + idf_portNum);
command.Execute();
command = client.CreateCommand("vlan 40");
command.Execute();
command = client.CreateCommand("no tag eth" + idf_switchNum + "/" + idf_cableType + "/" + idf_portNum);
command.Execute();
command = client.CreateCommand("vlan 50");
command.Execute();
command = client.CreateCommand("no tag eth" + idf_switchNum + "/" + idf_cableType + "/" + idf_portNum);
command.Execute();
command = client.CreateCommand("int eth" + idf_switchNum + "/" + idf_cableType + "/" + idf_portNum);
command.Execute();
command = client.CreateCommand("Dual 10");
command.Execute();
client.Disconnect();
}
}
public LacunaBot()
{
discord = new DiscordClient(x => {
x.LogLevel = LogSeverity.Info;
x.LogHandler = Log;
});
discord.UsingCommands(x => {
x.PrefixChar = '$';
x.AllowMentionPrefix = true;
});
var commands = discord.GetService <CommandService>();
commands.CreateCommand("ip")
.Parameter("ip", ParameterType.Optional)
.Do(async(e) =>
{
if (e.GetArg("ip") == "")
{
await e.Channel.SendMessage("The current IP is:" + Globals.ip);
}
else
{
Globals.ip = e.GetArg("ip");
await e.Channel.SendMessage(Globals.ip + " is the current IP!");
}
});
commands.CreateCommand("user")
.Parameter("user", ParameterType.Optional)
.Do(async(e) =>
{
if (e.GetArg("user") == "")
{
await e.Channel.SendMessage("The current User is:" + Globals.ip);
}
else
{
Globals.user2 = e.GetArg("user");
await e.Channel.SendMessage(Globals.user2 + " is the current user!");
}
});
commands.CreateCommand("password")
.Parameter("password", ParameterType.Optional)
.Do(async(e) =>
{
Globals.password = e.GetArg("password");
await e.Channel.SendMessage("Set password.");
});
commands.CreateCommand("help")
.Do(async(e) => {
await e.Channel.SendMessage("__**Hello I am SSHC!** I can connect to a server! :desktop:__ !\nHere are my commands:```css\n$ip 🔗 Set the IP for server connection(ex. $ip \"localhost\")\n$user 🔗 Set the User for server connection(ex. $user \"root\")\n$password 🔗 Set the Password for server connection(ex. $password \"tux\")\n$command 🔗 Send a command to the IP, User, and password provided via SSH!\n$current 🔗 Check current server Info.```\n\n Created by Static#3512");
});
commands.CreateCommand("command")
.Parameter("commandargs")
.Do(async(e) => {
if (Globals.ip == "")
{
await e.Channel.SendMessage("The Server's IP is not set!");
}
if (Globals.user2 == "")
{
await e.Channel.SendMessage("The Server's User is not set!");
}
if (Globals.password == "")
{
await e.Channel.SendMessage("The Server's Password is not set!");
}
using (var client = new SshClient(Globals.ip, Globals.user2, Globals.password))
{
// Dont even connect if user is not administrator!
if (e.User.ServerPermissions.Administrator == true)
{
client.Connect();
if (client.IsConnected == true)
{
var cmd = client.CreateCommand(e.GetArg("commandargs"));
await e.Channel.SendMessage("Executing ```css\n" + e.GetArg("commandargs") + "```");
cmd.Execute();
var result = cmd.Result;
await e.Channel.SendMessage(result);
}
else
{
await e.Channel.SendMessage("Failed to connect! Make sure your info. is correct.");
}
}
else
{
await e.Channel.SendMessage(e.User.ToString() + ", you do not have access to command!");
}
}
});
commands.CreateCommand("current")
.Do(async(e) => {
await e.Channel.SendMessage("**⇩ __Current Server Info__ ⇩**\n\n```" + Globals.ip.ToString() + "\n" + Globals.user2 + "\n" + Globals.password + "```");
});
#region Token
discord.ExecuteAndWait(async() => {
// ENTER YOUR TOKEN!!! <============
await discord.Connect("token", TokenType.Bot);
discord.SetGame("ver. 2.0");
});
#endregion
}
static void Main(string[] args)
{
string key = "";
string user = "******";
string password = "";
string command = "";
bool keyAuth = false;
List <string> hosts = new List <string>();
foreach (string arg in args)
{
switch (arg.Split(':')[0])
{
case "/user":
user = arg.Split(':')[1];
break;
case "/key":
key = arg.Split(':')[1];
keyAuth = true;
break;
case "/password":
password = arg.Split(':')[1];
break;
case "/hosts":
hosts = arg.Split(':')[1].Split(',').ToList <string>();
break;
case "/command":
command = arg.Split(':')[1];
break;
case "/b64":
password = Encoding.ASCII.GetString(Convert.FromBase64String(arg.Split(':')[1]));
break;
}
}
try
{
ConnectionInfo connectionInfo;
if (!(String.IsNullOrEmpty(key) && String.IsNullOrEmpty(password)) && hosts.Count > 0 && !String.IsNullOrEmpty(command))
{
if (keyAuth)
{
foreach (string host in hosts)
{
try
{
Console.WriteLine($"Running {command} on {host} with Key");
connectionInfo = new ConnectionInfo(host, user, new PrivateKeyAuthenticationMethod(key));
SshClient sshclient = new SshClient(connectionInfo);
sshclient.Connect();
SshCommand sc = sshclient.CreateCommand(command);
sc.Execute();
if (sc.ExitStatus != 0)
{
Console.WriteLine($"Error in Command on Host {host}");
Console.WriteLine("Error: {0}", sc.Error);
Console.WriteLine("Exit Status: {0}", sc.ExitStatus);
}
else
{
Console.WriteLine($"{host}: " + sc.Result);
}
}
catch (Exception e)
{
Console.WriteLine($"Host: {host}\r\n{e.Message}");
}
}
}
else
{
foreach (string host in hosts)
{
try
{
Console.WriteLine($"Running {command} on {host} with password {password}");
connectionInfo = new ConnectionInfo(host, user, new PasswordAuthenticationMethod(user, password));
SshClient sshclient = new SshClient(connectionInfo);
sshclient.Connect();
SshCommand sc = sshclient.CreateCommand(command);
sc.Execute();
if (sc.ExitStatus != 0)
{
Console.WriteLine($"Error in Command on Host {host}");
Console.WriteLine("Error: {0}", sc.Error);
Console.WriteLine("Exit Status: {0}", sc.ExitStatus);
}
else
{
Console.WriteLine($"{host}: " + sc.Result);
}
}
catch (Exception e)
{
Console.WriteLine($"Host: {host}\r\n{e.Message}");
}
}
}
}
else
{
Console.WriteLine("usage sshiva.exe /user:root /host:localhost /password:P@ssw0rd /command:\"whoami\"");
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
/// <summary>
/// Default Constructor
/// </summary>
/// <param name="address">IP Address : From CSV File</param>
/// <param name="community">SNMP Community : From CSV File</param>
/// <param name="username">SNMP UserName : From CSV File</param>
/// <param name="password">SNMP Password : From CSV File</param>
public IsilonCluster(string address, string community, string username, string password)
{
// Get Variable that are used in more than one place)
string clusterGUID = SNMP.GetSNMP(SNMP.clusterGUID, address, 161, community)[0].Data.ToString();
string clusterName = SNMP.GetSNMP(SNMP.clusterName, address, 161, community)[0].Data.ToString();
string configuredNodes = SNMP.GetSNMP(SNMP.configuredNodes, address, 161, community)[0].Data.ToString();
int nodeCount = Convert.ToInt32(SNMP.GetSNMP(SNMP.nodeCount, address, 161, community)[0].Data.ToString());
// Get and Calculate capacity
Double capacity = Convert.ToDouble(SNMP.GetSNMP(SNMP.ifsTotalBytes, address, 161, community)[0].Data.ToString());
capacity = Math.Round((capacity / 1024 / 1024 / 1024 / 1024), 2);
// Get and Calculate Used Capacity
Double used = Convert.ToDouble(SNMP.GetSNMP(SNMP.ifsUsedBytes, address, 161, community)[0].Data.ToString());
used = Math.Round((used / 1024 / 1024 / 1024 / 1024), 2);
// Get and Calculate Available Capacity
Double available = Convert.ToDouble(SNMP.GetSNMP(SNMP.ifsAvailableBytes, address, 161, community)[0].Data.ToString());
available = Math.Round((available / 1024 / 1024 / 1024 / 1024), 2);
// Calculate Percentage Used
Double percentageUsed = Math.Round(((used / capacity) * 100), 2);
// Create Root Entity Class & Display Name Prop
ManagementPackClass mpc_Entity = SCOM.GetManagementPackClass("System.Entity");
ManagementPackProperty mpp_EntityDisplayName = mpc_Entity.PropertyCollection["DisplayName"];
// Create Cluster Management Pack Class
ManagementPackClass mpc_Cluster = SCOM.GetManagementPackClass("AP.Isilon.Cluster");
// Create New Cluster Object
SCOM_Object = new CreatableEnterpriseManagementObject(SCOM.m_managementGroup, mpc_Cluster);
// Display Name of Root Entity (KEY Property)
SCOM_Object[mpp_EntityDisplayName].Value = clusterName;
// Set Properties of Cluster
//Starting with name (Key Property of Cluster)
ManagementPackProperty mpp_ClusterName = mpc_Cluster.PropertyCollection["Name"];
SCOM_Object[mpp_ClusterName].Value = clusterName;
// GUID Property
ManagementPackProperty mpp_ClusterGUID = mpc_Cluster.PropertyCollection["GUID"];
SCOM_Object[mpp_ClusterGUID].Value = clusterGUID;
// IPAddress
ManagementPackProperty mpp_ClusterIP = mpc_Cluster.PropertyCollection["IPAddress"];
SCOM_Object[mpp_ClusterIP].Value = address;
// SNMP Community String
ManagementPackProperty mpp_ClusterCommunity = mpc_Cluster.PropertyCollection["Community"];
SCOM_Object[mpp_ClusterCommunity].Value = community;
// NodeCount
ManagementPackProperty mpp_ClusterNodeCount = mpc_Cluster.PropertyCollection["NodeCount"];
SCOM_Object[mpp_ClusterNodeCount].Value = nodeCount;
// Configured Nodes
ManagementPackProperty mpp_ClusterConfiguredNodes = mpc_Cluster.PropertyCollection["ConfiguredNodes"];
SCOM_Object[mpp_ClusterConfiguredNodes].Value = configuredNodes;
// Online Nodes
ManagementPackProperty mpp_ClusterOnlineNodes = mpc_Cluster.PropertyCollection["OnlineNodes"];
SCOM_Object[mpp_ClusterOnlineNodes].Value = SNMP.GetSNMP(SNMP.onlineNodes, address, 161, community)[0].Data.ToString();
// Offline Nodes
ManagementPackProperty mpp_ClusterOfflineNodes = mpc_Cluster.PropertyCollection["OfflineNodes"];
SCOM_Object[mpp_ClusterOfflineNodes].Value = SNMP.GetSNMP(SNMP.offlineNodes, address, 161, community)[0].Data.ToString();
// Location
ManagementPackProperty mpp_ClusterLocation = mpc_Cluster.PropertyCollection["Location"];
SCOM_Object[mpp_ClusterLocation].Value = SNMP.GetSNMP(SNMP.sysLocation, address, 161, community)[0].Data.ToString();
// Contact
ManagementPackProperty mpp_ClusterContact = mpc_Cluster.PropertyCollection["Contact"];
SCOM_Object[mpp_ClusterContact].Value = SNMP.GetSNMP(SNMP.sysContact, address, 161, community)[0].Data.ToString();
// Capacity
ManagementPackProperty mpp_ClusterCapacity = mpc_Cluster.PropertyCollection["Capacity"];
SCOM_Object[mpp_ClusterCapacity].Value = capacity;
// Used Capacity
ManagementPackProperty mpp_ClusterUsedCapacity = mpc_Cluster.PropertyCollection["Used"];
SCOM_Object[mpp_ClusterUsedCapacity].Value = used;
// Available Capacity
ManagementPackProperty mpp_ClusterAvailableCapacity = mpc_Cluster.PropertyCollection["Available"];
SCOM_Object[mpp_ClusterAvailableCapacity].Value = available;
// Used Percentage
ManagementPackProperty mpp_ClusterUsedPercentage = mpc_Cluster.PropertyCollection["UsedPercentage"];
SCOM_Object[mpp_ClusterUsedPercentage].Value = percentageUsed;
// Get Nodes
try
{
// Create SSH Connection to Cluster
client = new SshClient(address, username, password);
client.Connect();
// Loop Though All Nodes
for (int i = 1; i <= nodeCount; i++)
{
// Get Interfaces for this Node
var cmd = client.CreateCommand("isi network interfaces list -v -z -a -n " + i + " --format json");
cmd.Execute();
// Collect Result (Will be In JSON Format
string result = cmd.Result;
JavaScriptSerializer js = new JavaScriptSerializer();
IsilonNetworkInterface[] interfaces = js.Deserialize <IsilonNetworkInterface[]>(result);
// Create New Node
IsilonNode newNode = new IsilonNode(clusterName, i, interfaces, address, community);
// Add Node to NodeList
NodeList.Add(newNode);
}
// Dispose of Cluster SSH Connection
client.Disconnect();
client.Dispose();
}
catch (Exception ex)
{
if (client.IsConnected)
{
client.Disconnect();
client.Dispose();
}
Program.log.Error(clusterName + " : " + ex.Message);
}
}
public void Test_Execute_Command_with_ExtendedOutput()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var cmd = client.CreateCommand("echo 12345; echo 654321 >&2");
cmd.Execute();
//var extendedData = Encoding.ASCII.GetString(cmd.ExtendedOutputStream.ToArray());
var extendedData = new StreamReader(cmd.ExtendedOutputStream, Encoding.ASCII).ReadToEnd();
client.Disconnect();
Assert.AreEqual("12345\n", cmd.Result);
Assert.AreEqual("654321\n", extendedData);
}
}
string ExecuteSyncCommand(SshClient client, string action)
{
SshCommand command = client.CreateCommand(String.Format(UNIX_COMMAND_FORMAT, _serviceName, action, username, password));
return(command.Execute());
}
public void Test_Execute_InvalidCommand_Then_Execute_ValidCommand()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var cmd = client.CreateCommand(";");
cmd.Execute();
if (string.IsNullOrEmpty(cmd.Error))
{
Assert.Fail("Operation should fail");
}
Assert.IsTrue(cmd.ExitStatus > 0);
var result = ExecuteTestCommand(client);
client.Disconnect();
Assert.IsTrue(result);
}
}
void ExecuteAsyncCommand(SshClient client, string action, AsyncCallback callBack, SshCommand command)
{
command = client.CreateCommand(String.Format(UNIX_COMMAND_FORMAT, _serviceName, action), UTF8Encoding.UTF8);
command.BeginExecute(String.Format(UNIX_COMMAND_FORMAT, _serviceName, action), callBack, null);
}
public static string GetUserland(SshClient sshClient) => sshClient.CreateCommand("sudo freebsd-version -u").Execute();
/////////////////////////////////////////////////////////
// 概要：ssh接続処理
// はまみ：2020/02/20
/////////////////////////////////////////////////////////
static public Boolean Connect(string strHostName, string strLoginId, string strPassword, ref string strResult)
{
Boolean bRet = true;
try
{
// 接続情報
ConnectionInfo ConnNfo = new ConnectionInfo(strHostName, 22, strLoginId, new PasswordAuthenticationMethod(strLoginId, strPassword));
// SSHクライアント生成
m_sshClient = new SshClient(ConnNfo);
m_sshClient.ConnectionInfo.Timeout = new TimeSpan(0, 0, 5);
// SSH接続
m_sshClient.Connect();
// SSH接続成功
if (m_sshClient.IsConnected)
{
using (var client = new SftpClient(ConnNfo))
{
//接続してアップロードディレクトリに移動
client.Connect();
client.ChangeDirectory("opensmile");
string fileName = (@"C:\Users\kikuc\Desktop\gokon-master-2018\Assets\WAV\result.wav");
Debug.Log(fileName);
using (var fs = System.IO.File.OpenRead(fileName))
{
//ファイルのアップロード（trueで上書き）
client.UploadFile(fs, "result.wav", true);
}
//接続してダウンロードディレクトリに移動
m_shellStream = m_sshClient.CreateShellStream("", 80, 40, 80, 40, 1024);
StreamReader streamReader = new StreamReader(m_shellStream, Encoding.GetEncoding("shift_jis"));
StreamWriter streamWriter = new StreamWriter(m_shellStream, Encoding.GetEncoding("shift_jis"));
streamWriter.AutoFlush = true;
//Thread.Sleep(2000);
var cmd = "sh /home/yutaka/opensmile/opensmile.sh";
streamWriter.WriteLine(cmd);
SshCommand sc = m_sshClient.CreateCommand(cmd);
sc.Execute();
string answer = sc.Result;
f_answer = answer;
Debug.Log("1:" + answer);
//var result = streamReader.ReadToEnd();
ResultData.result = answer;
//Debug.Log("2:"+result);
client.Disconnect();
//client.Connect();
//client.ChangeDirectory("opensmile");
//using (var fs = System.IO.File.OpenWrite("text.txt"))
//{
//ファイルのダウンロード
//client.DownloadFile(@"C:\Users\kikuc\Desktop\gokon-master-2018\Assets\WAV\text.txt", fs);
//}
//client.Disconnect();
}
// コマンド実行
m_shellStream.Dispose();
m_sshClient.Disconnect();
m_sshClient.Dispose();
//別手法
}
}
catch (Exception ex)
{
bRet = false;
strResult = ex.ToString();
}
return(bRet);
}
public void lancer()
{
try
{
localaddrr = IPAddress.Parse("127.0.0.1");
server = new TcpListener(localaddrr, port);
server.Start();
while (true)
{
Console.WriteLine("waiting for connexion");
TcpClient client = server.AcceptTcpClient();
Console.WriteLine("connected");
/*** opening the stream for sending and receiving data **/
String str = "";
NetworkStream stream = client.GetStream();
sr = new StreamReader(stream);
sw = new StreamWriter(stream);
String address, user, mdp;
address = null;
user = null; mdp = null;
for (int i = 0; i < 3; i++)
{
if (i == 0)
{
address = sr.ReadLine();
}
else if (i == 1)
{
user = sr.ReadLine();
}
else
{
mdp = sr.ReadLine();
}
}
if (connection(address, user, mdp) == 0)
{
sw.WriteLine("Welcome your are now Connected ");
sw.Flush();
do
{
str = sr.ReadLine();
/*** The clientssh is static so it use here to create a ssh Command***/
SshCommand cmd = clientssh.CreateCommand(str.ToString());
Console.WriteLine(str.ToString());
cmd.Execute();
if (str.Equals("end", StringComparison.OrdinalIgnoreCase))
{
str = "End transmission";
}
else
{
sw.WriteLine(">" + cmd.Result);
sw.Flush();
}
} while (!str.Equals("End transmission", StringComparison.OrdinalIgnoreCase));
clientssh.Disconnect();
client.Close();
}
else
{
sw.WriteLine("Connexion failure ");
sw.Flush();
}
}
}
catch (SocketException e)
{
Console.WriteLine(e.ToString());
}
catch (IOException e)
{
Console.WriteLine(e.ToString());
}
finally
{
server.Stop();
}
}
protected void btnEnviar_Command(object sender, CommandEventArgs e)
{
try
{
LoDevices objLo = new LoDevices();
EnDevices objEn = new EnDevices();
DataTable dt = new DataTable();
int index = Convert.ToInt32(e.CommandArgument);
Label rowid = (Label)grvListado.Rows[index].FindControl("lblrowid");
Label lblDip = (Label)grvListado.Rows[index].FindControl("lblDip");
dt = objLo.DevicesJson_Selecionar(Convert.ToInt32(rowid.Text));
string ruta = "/files/config.json";
// Setup Credentials and Server Information
ConnectionInfo ConnNfo = new ConnectionInfo("104.248.211.185", 22, "root", new AuthenticationMethod[] {
// Pasword based Authentication
new PasswordAuthenticationMethod("root", "iota2019123"),
// Key Based Authentication (using keys in OpenSSH Format)
new PrivateKeyAuthenticationMethod("root", new PrivateKeyFile[] {
new PrivateKeyFile(@"..\openssh.key", "passphrase")
}),
}
);
// Execute a (SHELL) Command - prepare upload directory
using (var sshclient = new SshClient(ConnNfo))
{
sshclient.Connect();
using (var cmd = sshclient.CreateCommand("mkdir -p /tmp/uploadtest && chmod +rw /tmp/uploadtest"))
{
cmd.Execute();
Console.WriteLine("Command>" + cmd.CommandText);
Console.WriteLine("Return Value = {0}", cmd.ExitStatus);
}
sshclient.Disconnect();
}
// Upload A File
using (var sftp1 = new SftpClient(ConnNfo))
{
string uploadfn = "Renci.SshNet.dll";
sftp1.Connect();
sftp1.ChangeDirectory("/opt/prueba/");
using (var uplfileStream = System.IO.File.OpenRead(uploadfn))
{
sftp1.UploadFile(uplfileStream, uploadfn, true);
}
sftp1.Disconnect();
}
// Execute (SHELL) Commands
using (var sshclient = new SshClient(ConnNfo))
{
sshclient.Connect();
// quick way to use ist, but not best practice - SshCommand is not Disposed, ExitStatus not checked...
Console.WriteLine(sshclient.CreateCommand("cd /tmp && ls -lah").Execute());
Console.WriteLine(sshclient.CreateCommand("pwd").Execute());
Console.WriteLine(sshclient.CreateCommand("cd /tmp/uploadtest && ls -lah").Execute());
sshclient.Disconnect();
}
Console.ReadKey();
//using (var client = new SshClient("104.248.211.185", "root", "iota2019123"))
//{
// client.Connect();
// //client.RunCommand("etc/init.d/networking restart");
// client.RunCommand ChangeDirectory("/opt/prueba/");
// using (var uplfileStream = System.IO.File.OpenRead(ruta))
// {
// client.UploadFile(uplfileStream, ruta, true);
// }
// client.Disconnect();
// client.Disconnect();
//}
// SendFileToServer.Send(ruta);
return;
FileInfo Archivo = new FileInfo(HttpContext.Current.Server.MapPath(ruta));
File.WriteAllText(HttpContext.Current.Server.MapPath(ruta), dt.Rows[0]["DJson"].ToString());
string destino = "/opt/prueba/";
string host = lblDip.Text.Trim();
string username = grvListado.DataKeys[index].Values["usuario"].ToString();
string password = Seguridad.DesEncriptar(grvListado.DataKeys[index].Values["clave"].ToString());
SFTPHelper sftp = new SFTPHelper(host, username, password);
sftp.Connect();
sftp.Get(ruta, destino);
sftp.Disconnect();
}
catch (Exception ex)
{
throw ex;
}
}
private void BackgroundWorker(DateTime startedTime)
{
try
{
while (true)
{
using (LocalDbContext dbContext = new LocalDbContext())
{
foreach (CharacterFind characterFind in names.Where(x => !x.Found))
{
CharacterInfo user = dbContext.Users
.Where(first =>
first.name == characterFind.CharacterName)
.FirstOrDefault();
using (var client = new SshClient("192.168.41.28", 22, "root", "F1reF0x"))
{
client.Connect();
string command = $"/usr/local/bin/docker-compose -f /opt/Seat/docker-compose.yml --project-directory /opt/Seat/ exec -T seat-web su -c 'php artisan esi:job:dispatch \"Seat\\\\Eveapi\\\\Jobs\\\\Location\\\\Character\\\\Online\" --character_id={user.character_id}'";
//string command = "echo test";
using (var cmd = client.CreateCommand(command))
{
cmd.Execute();
if (cmd.ExitStatus != 0)
{
Console.WriteLine("Command>" + cmd.CommandText);
Console.WriteLine("Result>" + cmd.Result);
Console.WriteLine("Error>" + cmd.Error);
Console.WriteLine("Return Value = {0}", cmd.ExitStatus);
}
}
client.Disconnect();
}
}
}
Thread.Sleep(20000);
using (LocalDbContext dbContext = new LocalDbContext())
{
foreach (CharacterFind characterFind in names.Where(x => !x.Found))
{
CharacterInfo user = dbContext.Users
.Where(first =>
first.name == characterFind.CharacterName)
.FirstOrDefault();
CharacterOnline online = dbContext.Online
.Where(first =>
first.character_id == user.character_id)
.FirstOrDefault();
if (online.online || online.last_login > startedTime)
{
CharacterFind result = names.FirstOrDefault(x => characterFind.CharacterName == x.CharacterName);
if (result != null)
{
result.Found = true;
}
}
}
}
Thread.Sleep(60000);
}
}
catch (Exception error)
{
Console.WriteLine($"Crashy : {error.Message}");
BackgroundWorker(startedTime);
}
}
public static void MacHostJob(string simulator)
{
Program.MainLogger.Info($"Starting connection to host {Config.MacHost.Host}, port {Config.MacHost.Port}, user {Config.MacHost.User}");
var deviceId = "";
using (var sshClient = new SshClient(Config.MacHost.Host, Config.MacHost.Port, Config.MacHost.User, Config.MacHost.Password))
{
sshClient.ErrorOccurred += SshClientOnErrorOccurred;
sshClient.Connect();
//if the selected emulator contains the iOS version in his name,
//we need a bit of string "magic" to find the right UDID
if (simulator.Contains(" iOS "))
{
Program.MainLogger.Info("Input contains iOS version, activating advanced seatch for simulators");
var versionPosition = simulator.IndexOf(" iOS ", StringComparison.Ordinal);
var iosVersion = simulator.Substring(versionPosition + 5).Replace(".", "-");
var simulatorKey = "com.apple.CoreSimulator.SimRuntime.iOS-" + iosVersion;
Program.MainLogger.Info("iOS version extracted: " + iosVersion);
Program.MainLogger.Info("Dicitonary key generated: " + simulatorKey);
Program.MainLogger.Info("Reading emulator list");
var comando = "xcrun simctl list --json";
SimCtlResponseModel simCtlResponse;
using (var cmd = sshClient.CreateCommand(comando))
{
cmd.Execute();
simCtlResponse = JsonConvert.DeserializeObject <SimCtlResponseModel>(cmd.Result);
}
if (simCtlResponse?.Devices != null && simCtlResponse.Devices.ContainsKey(simulatorKey))
{
var deviceName = simulator.Substring(0, versionPosition);
var device = simCtlResponse.Devices[simulatorKey].FirstOrDefault(x => x.IsAvailable && x.Name == deviceName);
if (device != null)
{
deviceId = device.Udid;
}
else
{
Program.MainLogger.Warn($"Key found but no corresponding simulator found");
}
}
else
{
Program.MainLogger.Warn("Unable to find simultors in the specified dictionary key");
}
}
else
{
//No iOS version = only 1 simulator = bash magic!!!
Program.MainLogger.Info("Input device does not contain iOS version, recovering the UUID with a single bash command");
var comando = "echo $( xcrun simctl list devices | grep -w '" + simulator +
" ' | grep -v -e 'unavailable' | awk 'match($0, /\\(([-0-9A-F]+)\\)/) { print substr( $0, RSTART + 1, RLENGTH - 2 )}' )";
using (var cmd = sshClient.CreateCommand(comando))
{
cmd.Execute();
deviceId = cmd.Result;
}
}
sshClient.Disconnect();
sshClient.ErrorOccurred -= SshClientOnErrorOccurred;
}
if (!string.IsNullOrEmpty(deviceId))
{
Program.MainLogger.Info($"Device UDID found: {deviceId}");
Program.MainLogger.Info("Starting the Remote Simulator");
RemoteSimulatorHelper.OpenSimulator(deviceId);
}
else
{
Program.MainLogger.Warn("Device UDID not found, unable to start the Remote Simulator");
}
}
/// <summary>
/// Launch <paramref name="exePath"/> on remote host using credentials stored in EditorSettings.
/// Before launching all the files requires by <paramref name="exePath"/> are copied over to host
/// using the location specified in EditorSettings.Location. If <paramref name="isCoreCLR"/> is set
/// all the Xenko native libraries are copied over to the current directory of the game on the remote
/// host via the `CoreCLRSetup` script.
/// </summary>
/// <param name="logger">Logger to show progress and any issues that may occur.</param>
/// <param name="exePath">Path on the local machine where the executable was compiled.</param>
/// <param name="isCoreCLR">Is <paramref name="exePath"/> executed against .NET Core?</param>
/// <returns>True when launch was successful, false otherwise.</returns>
internal static bool Launch([NotNull] LoggerResult logger, [NotNull] UFile exePath, bool isCoreCLR)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (exePath == null)
{
throw new ArgumentNullException(nameof(exePath));
}
var host = XenkoEditorSettings.Host.GetValue();
var username = XenkoEditorSettings.Username.GetValue();
var port = XenkoEditorSettings.Port.GetValue();
var password = Decrypt(XenkoEditorSettings.Password.GetValue());
var location = new UDirectory(XenkoEditorSettings.Location.GetValue());
var display = XenkoEditorSettings.Display.GetValue();
var connectInfo = NewConnectionInfo(host, port, username, password);
if (SyncTo(connectInfo, exePath.GetFullDirectory(), UPath.Combine(location, new UDirectory(exePath.GetFileNameWithoutExtension())), logger))
{
var sshClient = new SshClient(connectInfo);
try
{
sshClient.Connect();
if (sshClient.IsConnected)
{
string cmdString;
SshCommand cmd;
// Due to lack of Dllmap config for CoreCLR, we have to ensure that our native libraries
// are copied next to the executable. The CoreCLRSetup script will check the 32-bit vs 64-bit
// of the `dotnet` runner and copy the .so files from the proper x86 or x64 directory.
if (isCoreCLR)
{
cmdString = "bash -c 'source /etc/profile ; cd " + location + "/" + exePath.GetFileNameWithoutExtension() + ";" + "sh ./CoreCLRSetup.sh'";
cmd = sshClient.CreateCommand(cmdString);
cmd.Execute();
var err = cmd.Error;
if (!string.IsNullOrEmpty(err))
{
logger.Error(err);
// We don't exit here in case of failure, we just print the error and continue
// Users can then try to fix the issue directly on the remote host.
}
else
{
err = cmd.Result;
if (!string.IsNullOrEmpty(err))
{
logger.Info(err);
}
}
}
// Try to get the main IP of the machine
var ipv4 = GetAllLocalIPv4().FirstOrDefault();
var connectionRouter = string.Empty;
if (!string.IsNullOrEmpty(ipv4))
{
connectionRouter = " XenkoConnectionRouterRemoteIP=" + ipv4;
}
var dotnetEngine = XenkoEditorSettings.UseCoreCLR.GetValue() ? " dotnet " : " mono ";
if (!string.IsNullOrEmpty(display))
{
display = " DISPLAY=" + display;
}
else
{
display = " DISPLAY=:0.0";
}
cmdString = "bash -c 'source /etc/profile ; cd " + location + "/" + exePath.GetFileNameWithoutExtension() + ";" + display + connectionRouter + dotnetEngine + "./" + exePath.GetFileName() + "'";
cmd = sshClient.CreateCommand(cmdString);
cmd.BeginExecute((callback) =>
{
var res = cmd.Error;
if (!string.IsNullOrEmpty(res))
{
logger.Error(res);
}
else
{
res = cmd.Result;
if (!string.IsNullOrEmpty(res))
{
logger.Info(res);
}
}
// Dispose of our resources as soon as we are done.
cmd.Dispose();
sshClient.Dispose();
});
return(true);
}
}
catch (Exception)
{
var message = Tr._p("Message", "Unable to launch {0} on host {1}");
logger.Error(string.Format(message, exePath, host));
}
}
return(false);
}
private void BackgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
_capturedData = 0;
var connectionInfo = new ConnectionInfo(textBoxIP.Text,
textBoxUsername.Text,
new PasswordAuthenticationMethod(textBoxUsername.Text, textBoxPassword.Text));
_client = new SshClient(connectionInfo);
_client.Connect();
PrintCommand(_client.RunCommand("mkfifo /tmp/remcap"));
var command = _client.CreateCommand("cat /tmp/remcap");
command.BeginExecute();
_stream = command.OutputStream;
var combine = Path.Combine(textBoxFolder.Text, textBoxPrefix.Text);
int filetick = 0;
while (File.Exists(combine + filetick + ".pcap"))
{
filetick++;
}
_lastFile = combine + filetick + ".pcap";
ThreadPool.QueueUserWorkItem(x =>
{
var fileStream = new FileStream(_lastFile, FileMode.Create);
int wait = 0;
while (_stream.CanRead)
{
var readByte = _stream.ReadByte();
if (readByte == -1)
{
if (wait > 10)
{
if (_client.IsConnected == false)
{
break;
}
}
Thread.Sleep(100);
wait++;
}
else
{
fileStream.WriteByte((byte)readByte);
_capturedData++;
wait = 0;
}
//if (_stopCapture)
//{
// sshClientPipe.Disconnect();
//
//}
}
Print("Stream can no longer be read");
fileStream.Flush();
fileStream.Close();
});
Thread.Sleep(500);
var tcpdumpcommand =
_client.CreateCommand("tcpdump -s 0 -U -n -w - -i any not port " + textBoxPort.Text + " > /tmp/remcap");
tcpdumpcommand.BeginExecute();
PrintCommand(tcpdumpcommand);
//PrintCommand(sshClientCommand.RunCommand("tcpdump -i any -w /tmp/remcap not port " + textBoxPort.Text + ""));
//var stream = command.OutputStream;
//using (var fileStream = new FileStream("c:\\temp\\tryfile", FileMode.Create))
//{
// command.Execute();
// while (stream.CanRead)
// {
// byte[] buffer = new byte[24];
// stream.Read(buffer, (int) stream.Position, buffer.Length);
// fileStream.Write(buffer, (int) fileStream.Position, buffer.Length);
// }
//}
while (_client.IsConnected)
{
Thread.Sleep(1000);
}
}
public void Test_Execute_Invalid_Command()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
#region Example SshCommand CreateCommand Error
client.Connect();
var cmd = client.CreateCommand(";");
cmd.Execute();
if (!string.IsNullOrEmpty(cmd.Error))
{
Console.WriteLine(cmd.Error);
}
client.Disconnect();
#endregion
Assert.Inconclusive();
}
}
//UiKit
internal void Sbreload()
{
sshclient.ConnectionInfo.Timeout = TimeSpan.FromSeconds(8);
if (!sshclient.IsConnected)
{
sshclient.Connect();
}
sshclient.CreateCommand("sbreload").Execute();
sshclient.Disconnect();
}
public void Test_Execute_OutputStream()
{
var host = Resources.HOST;
var username = Resources.USERNAME;
var password = Resources.PASSWORD;
using (var client = new SshClient(host, username, password))
{
#region Example SshCommand CreateCommand Execute OutputStream
client.Connect();
var cmd = client.CreateCommand("ls -l"); // very long list
var asynch = cmd.BeginExecute();
var reader = new StreamReader(cmd.OutputStream);
while (!asynch.IsCompleted)
{
var result = reader.ReadToEnd();
if (string.IsNullOrEmpty(result))
continue;
Console.Write(result);
}
cmd.EndExecute(asynch);
client.Disconnect();
#endregion
Assert.Inconclusive();
}
}
static int Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
var command = new RootCommand()
{
new Option <string>(
"--version",
getDefaultValue: (() => "1.12.2"),
description: "Set upload version."),
new Option <string>(
"--host",
getDefaultValue: (() => ""),
description: "Set the host."),
new Option <string>(
"--name",
description: "Set user name."),
new Option <string>(
"--password",
description: "Set password.")
};
command.Description = "Config of uploader";
command.Handler = CommandHandler.Create <string, string, string, string>((version, host, name, password) =>
{
using var scpClient = new ScpClient(host, 20002, name, password);
scpClient.Connect();
if (scpClient.IsConnected)
{
Log.Logger.Information("SCP服务器连接成功");
}
else
{
Log.Logger.Error("SCP服务器连接失败");
return;
}
var md5s = Directory.GetFiles(Directory.GetCurrentDirectory(), "*.md5");
md5s.ToList().ForEach(_ => { scpClient.Upload(File.OpenRead(_), $"/var/www/html/files/{Path.GetFileName(_)}"); });
var fs = File.OpenRead($"./Minecraft-Mod-Language-Package-{version}.zip");
switch (version)
{
case "1.12.2":
scpClient.Upload(fs, "/var/www/html/files/Minecraft-Mod-Language-Modpack.zip.1");
break;
case "1.16":
scpClient.Upload(fs, "/var/www/html/files/Minecraft-Mod-Language-Modpack-1-16.zip.1");
break;
case "1.18":
scpClient.Upload(fs, "/var/www/html/files/Minecraft-Mod-Language-Modpack-1-18.zip.1");
break;
default:
break; //不应该
}
Log.Logger.Information("上传成功");
scpClient.Dispose();
using var sshClient = new SshClient(host, 20002, name, password);
sshClient.Connect();
if (sshClient.IsConnected)
{
Log.Logger.Information("SSH服务器连接成功");
}
else
{
Log.Logger.Error("SSH服务器连接失败");
return;
}
switch (version)
{
case "1.12.2":
var cmd1 = sshClient.CreateCommand("mv /var/www/html/files/Minecraft-Mod-Language-Modpack.zip.1 /var/www/html/files/Minecraft-Mod-Language-Modpack.zip");
cmd1.Execute();
var err1 = cmd1.Error;
Log.Logger.Error(err1);
break;
case "1.16":
var cmd2 = sshClient.CreateCommand("mv /var/www/html/files/Minecraft-Mod-Language-Modpack-1-16.zip.1 /var/www/html/files/Minecraft-Mod-Language-Modpack-1-16.zip");
cmd2.Execute();
var err2 = cmd2.Error;
Log.Logger.Error(err2);
break;
case "1.18":
var cmd3 = sshClient.CreateCommand("mv /var/www/html/files/Minecraft-Mod-Language-Modpack-1-18.zip.1 /var/www/html/files/Minecraft-Mod-Language-Modpack-1-18.zip");
cmd3.Execute();
var err3 = cmd3.Error;
Log.Logger.Error(err3);
break;
default:
break; //不应该
}
sshClient.Dispose();
});
return(command.Invoke(args));
}
public void Test_Execute_Command_Same_Object_Different_Commands()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var cmd = client.CreateCommand("echo 12345");
cmd.Execute();
Assert.AreEqual("12345\n", cmd.Result);
cmd.Execute("echo 23456");
Assert.AreEqual("23456\n", cmd.Result);
client.Disconnect();
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello, this is a test SSH connection");
// Setup Credentials and Server Information
ConnectionInfo ConnNfo = new ConnectionInfo("192.168.0.106", 22, "pi",
new AuthenticationMethod[] {
// Pasword based Authentication
// new PasswordAuthenticationMethod("pi","catanf85"),
// Key Based Authentication (using keys in OpenSSH Format)
new PrivateKeyAuthenticationMethod("pi", new PrivateKeyFile[] {
new PrivateKeyFile(@"..\test.keys", "")
}),
}
);
// Execute a (SHELL) Command - prepare upload directory
using (var sshclient = new SshClient(ConnNfo))
{
sshclient.KeepAliveInterval = new TimeSpan(0, 0, 10);
sshclient.Connect();
using (var cmd = sshclient.CreateCommand("mkdir -p /tmp/uploadtest && chmod +rw /tmp/uploadtest"))
{
cmd.Execute();
Console.WriteLine("Command>" + cmd.CommandText);
Console.WriteLine("Return Value = {0}", cmd.ExitStatus);
}
if (sshclient.IsConnected)
{
try
{
// esempio di forwarding locale: dalla 22 del server ssh alla 9091 del pc client
var port = new ForwardedPortLocal("127.0.0.1", 9091, "127.0.0.1", 22);
sshclient.AddForwardedPort(port);
port.Start();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
try
{
// esempio di forwarding remoto: dalla 5001 del pc client alla 50000 del server ssh
var port = new ForwardedPortRemote("127.0.0.1", 50000, "127.0.0.1", 5001);
sshclient.AddForwardedPort(port);
port.Start();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
Console.ReadLine();
sshclient.Disconnect();
}
}
public static string GetRunning(SshClient sshClient) => sshClient.CreateCommand("sudo freebsd-version -r").Execute();
private void RunCommand()
{
// check if the windows wallet is installed at %AppData%\Bitradio\\
//if (!Directory.Exists(@"%AppData%\Bitradio\\"))
//{
// MessageBox.Show("Have you installed the Wallet at /%AppData%/Roaming/Bitradio ?"); //If not
// return;
//}
//check for existing masternode.conf
if (!File.Exists(@"%AppData%\Bitradio\\masternode.conf"))
{
using (StreamWriter sw = new StreamWriter(Environment.ExpandEnvironmentVariables(@"%AppData%\Bitradio\\masternode.conf"), true)) //if not than create
{
}
}
//load all variables
ip = ip_feld.Text;
username = username_feld.Text;
password = password_feld.Text;
port = port_feld.Text;
genkey = genkey_feld.Text;
output = output_feld.Text;
output_after = after_output_feld.Text;
masternodename = masternodename_feld.Text;
string TEMP_PATH = Path.GetTempPath();
//login and create connection
using (var client = new SshClient(ip, Convert.ToInt16(port), username, password))
{
// check if everything givem
try
{
client.Connect();
//port = null;
//masternodename = null;
//output_after = null;
//genkey = null;
//output = null;
}
catch
{
if (language_info == "deu")
{
MessageBox.Show("Bitte fülle die Felder IP, Benutzername, Benutzerpasswort, rcuser und rpcpasswort aus!");
}
else if (language_info == "rus")
{
MessageBox.Show("Пожалуйста, укажите IP, пользователя, пароль, ключ (genkey), порт, выход, число после выхода и имя мастерноды!");
}
else
{
MessageBox.Show("Please fill out the IP, user, password, genkey, port, output, after_output and masternodename!"); //if not
}
return;
}
// Crappy way!! I don't know how to transfer a lokal variable to the vps. So I create lokal a file with the genkey as name, upload it
// to the vps and read the new created directory. The output is the genkey :D
var command = client.CreateCommand("mkdir /root/temp_bitradio/");
var result = command.BeginExecute();
command = client.CreateCommand("cd /root/temp_bitradio/");
result = command.BeginExecute();
//create the lokale file
if (!File.Exists(TEMP_PATH + genkey))
{
using (StreamWriter sw = new StreamWriter(Environment.ExpandEnvironmentVariables(TEMP_PATH + genkey), true))
{
}
}
client.Disconnect();
}
//upload the file
using (var client = new SftpClient(ip, Convert.ToInt16(port), username, password))
{
client.Connect();
FileInfo f = new FileInfo(TEMP_PATH + genkey);
string uploadfile = f.FullName;
var fileStream = new FileStream(uploadfile, FileMode.Open);
if (fileStream != null)
{
client.UploadFile(fileStream, "/root/temp_bitradio/" + f.Name, null);
client.Disconnect();
client.Dispose();
}
}
// execute the ./Bitradiod install script (self-made)
using (var client = new SshClient(ip, Convert.ToInt16(port), username, password))
{
client.Connect();
var command = client.CreateCommand("./Bitradiod getblockcount");
var result = command.BeginExecute();
if (startup_checkbox.Checked)
{
command = client.CreateCommand("sudo wget https://raw.githubusercontent.com/Roalkege/bitradio_masternode_creator/master/Bitradio_MN_tool_cron.sh && bash Bitradio_MN_tool_cron.sh"); //download the script
result = command.BeginExecute();
}
else
{
command = client.CreateCommand("sudo wget https://raw.githubusercontent.com/Roalkege/bitradio_masternode_creator/master/Bitradio_MN_tool.sh && bash Bitradio_MN_tool.sh"); //download the script
result = command.BeginExecute();
}
//log vps output
using (var reader =
new StreamReader(command.OutputStream, Encoding.UTF8, true, 1024, true))
{
while (!result.IsCompleted || !reader.EndOfStream)
{
string line = reader.ReadLine();
if (line != null)
{
log_feld.Invoke(
(MethodInvoker)(() =>
log_feld.AppendText(line + Environment.NewLine)));
}
}
}
command.EndExecute(result);
command = client.CreateCommand("cd ~");
result = command.BeginExecute();
command = client.CreateCommand("rm Bitradio_MN_tool.sh"); //remove the script
result = command.BeginExecute();
if (language_info == "ger")
{
MessageBox.Show("Masternode wurde installiert, starte jetzt deine Windows Wallet neu und starte den Alias");
}
else if (language_info == "rus")
{
MessageBox.Show("Мастернода установлена, теперь перезагрузите кошелек и начните работать в режиме анонимности.");
}
else
{
MessageBox.Show("Masternode installed now restart your windows wallet and start the Alias");
}
client.Disconnect();
}
//edit the lokal masternode.conf
using (StreamWriter sw = new StreamWriter(Environment.ExpandEnvironmentVariables(TEMP_PATH + @"\masternode.conf"), true))
{
sw.Write(masternodename + " " + ip + ":32454 " + genkey + " " + output + " " + output_after + " " + "\r\n");
}
}
public void Test_Execute_Timeout()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var cmd = client.CreateCommand("sleep 10s");
cmd.CommandTimeout = TimeSpan.FromSeconds(5);
cmd.Execute();
client.Disconnect();
}
}
static void Main(string[] args)
{
Console.WriteLine("SSH Monitor.");
// read the settings by newtonsoft.json
List <string> additionalCommands = new List <string>()
{
//"sudo crontab -r",
//"service spider start"
};
DirectoryInfo baseDir = new DirectoryInfo(AppContext.BaseDirectory);
var sshFiles = baseDir.GetFiles("*.ssh.json");
if (sshFiles.Length == 0)
{
// create an example setting file
var example = new List <UbuntuOperation>()
{
new UbuntuOperation()
{
Name = "example connection",
Host = "host.com",
Username = "******",
Password = "******",
Commands = new List <BashCommand>()
{
new BashCommand()
{
Command = "ls -1 | wc -l",
Title = "Count Files in Root:"
}
}
}
};
string exampleFilename = "example.ssh.json";
File.WriteAllText($"{AppContext.BaseDirectory}/{exampleFilename}", JsonConvert.SerializeObject(example, Formatting.Indented));
Console.WriteLine($@"An Example Setting is generate to {exampleFilename}");
}
else
{
foreach (var setting in sshFiles)
{
var json = File.ReadAllText(setting.FullName);
var list = JsonConvert.DeserializeObject <List <UbuntuOperation> >(json);
// access each of linux server by ssh connection and execute the bash
foreach (var operation in list)
{
ConnectionInfo connectionInfo = new ConnectionInfo(operation.Host, operation.Username, new AuthenticationMethod[] {
new PasswordAuthenticationMethod(operation.Username, operation.Password)
});
SshClient sshClient = new SshClient(connectionInfo);
Console.WriteLine($"Connecting to {operation.Name} ({operation.Host}):");
sshClient.Connect();
if (operation.Commands != null)
{
foreach (var cmd in operation.Commands)
{
var result = sshClient.CreateCommand(cmd.Command).Execute();
if (cmd.Results == null)
{
cmd.Results = new List <BashResult>();
}
cmd.Results.Add(new BashResult()
{
Time = DateTime.Now,
Result = result
});
// print the last 3 results:
Console.WriteLine($"{cmd.Title}:");
for (var i = cmd.Results.Count - 1; i >= 0 && i > cmd.Results.Count - 4; i--)
{
Console.WriteLine($" {cmd.Results[i].Time} : {cmd.Results[i].Result}");
}
}
}
foreach (var cmd in additionalCommands)
{
var result = sshClient.CreateCommand(cmd).Execute();
}
}
File.WriteAllText(setting.FullName, JsonConvert.SerializeObject(list, Formatting.Indented));
}
}
Console.WriteLine("Press Any Key to Exit...");
Console.ReadKey();
}
private static bool ExecuteTestCommand(SshClient s)
{
var testValue = Guid.NewGuid().ToString();
var command = string.Format("echo {0}", testValue);
var cmd = s.CreateCommand(command);
var result = cmd.Execute();
result = result.Substring(0, result.Length - 1); // Remove \n character returned by command
return result.Equals(testValue);
}
public void ConfigurateDevice(StationModel station)
{
if (station?.InformationTable == null)
{
return;
}
UserName = station?.InformationTable?.UserNameDevice;
Password = station?.InformationTable?.PasswordDevice;
var ipAddressDevice = station?.InformationTable?.IpDevice;
var stationId = station.Id;
station.InformationTable
?.CheckAccessCode();
var accessCode = station.InformationTable
?.AccessCode;
using (var ssh = new SshClient(ipAddressDevice, UserName, Password))
{
try
{
ssh.Connect();
}
catch (Exception ex)
{
var manager = new ContextManager();
if (CheckPingDevice(ipAddressDevice))
{
StationModel newStation = null;
if (string.Equals(station.InformationTable.PasswordDevice, "$olnechniKrug2019"))
{
newStation = manager.ChangePassword(station, "$olnechniKrug");
}
else
{
newStation = manager.ChangePassword(station, "$olnechniKrug2019");
}
ConfigurateDevice(newStation);
}
Logger.WriteLog($"Произошла ошибка при попытки соеденения {ex.Message}, подробности {ex.StackTrace}", "ConfigurateDevice");
return;
}
var command = ssh.CreateCommand("ls .config/autostart", Encoding.UTF8);
command.Execute();
var answer = command.Result;
if (answer.Contains("chromium.desktop\n"))
{
command = ssh.CreateCommand("rm -f .config/autostart/chromium.desktop\n");
command.Execute();
}
using (var sftp = new SftpClient(ipAddressDevice, UserName, Password))
{
try
{
sftp.Connect();
}
catch (SshConnectionException ex)
{
Logger.WriteLog($"Произошла ошибка при попытки соеденения {ex.Message}, подробности {ex.StackTrace}", "ConfigurateDevice");
return;
}
var text = new List <string>();
text.Add("[Desktop Entry]");
text.Add("Encoding=UTF-8");
text.Add("Name=Connect");
text.Add("Comment=Checks internet connectivity");
text.Add($"Exec=/usr/bin/chromium-browser -incognito --noerrdialogs --kiosk http://92.50.187.210/citystations/Home/DisplayInformationTable?stationId={stationId}&accessCode={accessCode}");
try
{
sftp.AppendAllLines(".config/autostart/chromium.desktop", text);
}
catch (SftpPermissionDeniedException ex)
{
Logger.WriteLog($"Произошла ошибка при попытки создания файлов {ex.Message}, подробности {ex.StackTrace}", "ConfigurateDevice");
if (!ssh.IsConnected)
{
ssh.Connect();
}
command = ssh.CreateCommand("sudo rm -f -r .config/autostart\n");
try
{
command.Execute();
}
catch (SshException sshex)
{
Logger.WriteLog($"Произошла ошибка при попытки удаления папки {ex.Message}, подробности {ex.StackTrace}", "ConfigurateDevice");
return;
}
command = ssh.CreateCommand("mkdir .config/autostart\n");
try
{
command.Execute();
}
catch (SshException sshexep)
{
Logger.WriteLog($"Произошла ошибка при попытки создания папки {ex.Message}, подробности {ex.StackTrace}", "ConfigurateDevice");
return;
}
try
{
sftp.AppendAllLines(".config/autostart/chromium.desktop", text);
}
catch (SftpPermissionDeniedException sftpError)
{
Logger.WriteLog($"Произошла ошибка при попытки добавления данных в файл {ex.Message}, подробности {ex.StackTrace}", "ConfigurateDevice");
return;
}
}
}
if (!ssh.IsConnected)
{
ssh.Connect();
}
command = ssh.CreateCommand("sudo reboot now\n", Encoding.UTF8);
try
{
command.Execute();
}
catch (SshConnectionException ex)
{
Logger.WriteLog($"Выполнена перезагрузка устройства {ipAddressDevice}", "ConfigurateDevice");
return;
}
}
}
public void CreateCommand_CommandTextAndEncoding_NeverConnected()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, "invalid password"))
{
try
{
client.CreateCommand("ls", Encoding.UTF8);
Assert.Fail();
}
catch (SshConnectionException ex)
{
Assert.IsNull(ex.InnerException);
Assert.AreEqual("Client not connected.", ex.Message);
}
}
}
/// <summary>
/// Initiate shutdown
/// </summary>
private async void InitiateShutdown()
{
await Report("SHUTDOWN_INITIATED");
// Keyboard auth for ESXi server
var kbAuth = new KeyboardInteractiveAuthenticationMethod(_config.Esxi.Username);
kbAuth.AuthenticationPrompt += (sender, args) =>
{
foreach (var prompt in args.Prompts)
{
if (prompt.Request.IndexOf("Password:"******"Uploading shutdown script to /tmp");
using (var sftp = new SftpClient(sshInfo))
{
sftp.ErrorOccurred += (sender, args) =>
_logger.LogError(args.Exception, "An error occurred when connecting to ESXi server");
sftp.Connect();
sftp.ChangeDirectory("/tmp");
await using (var fileStream =
File.OpenRead(Path.Combine(_hostEnvironment.ContentRootPath, "shutdown.sh")))
{
sftp.UploadFile(fileStream, "shutdown.sh", true);
_logger.LogInformation("Upload complete");
}
sftp.Disconnect();
}
// Execute shutdown script
_logger.LogInformation("Executing shutdown script");
using (var sshClient = new SshClient(sshInfo))
{
sshClient.Connect();
if (!sshClient.IsConnected)
{
return;
}
using (var cmd = sshClient.CreateCommand("chmod +x /tmp/shutdown.sh && /tmp/shutdown.sh"))
{
cmd.Execute();
_logger.LogInformation("SSH command> {0}", cmd.CommandText);
_logger.LogInformation("SSH result> '{0}' ({1})", cmd.Result, cmd.ExitStatus);
if (cmd.ExitStatus == 0)
{
await Report("SHUTDOWN_COMPLETED");
}
}
sshClient.Disconnect();
}
}
private void SSHCommandThread(IP selectedIP, string command, string commandinresult, string login, string password, bool showWindow = true, bool addToListBoxTask = true)
{
Thread runThread = new Thread(new ThreadStart(() =>
{
ItemListBoxTask curItemLBT = new ItemListBoxTask()
{
IPOrName = selectedIP.NBNameOrIP(), Description = $"Выполняется {command}", CVZNumber = $"ЦВЗ№{SelectedTT.NumberCVZ.ToString()}", IsIndeterminate = true
};
//Dispatcher.Invoke(() =>
//{
if (addToListBoxTask)
{
Dispatcher.Invoke(() =>
{
Bindings.listBoxTaskItemsSource.Add(curItemLBT);
});
}
try
{
this.Log(string.Format($"Выполнение {command} на {selectedIP.NBNameOrIP()}..."), false, false, string.Empty, true);
string nbNameOrIP = selectedIP.NBNameOrIP();
string ipaddress = selectedIP.IPAddress;
using (SshClient client = new SshClient(ipaddress, login, password))
{
client.Connect();
StringBuilder commandBuild = new StringBuilder();
commandBuild.AppendLine(@"#!/bin/bash");
commandBuild.AppendLine($"TempPass={password}");
commandBuild.AppendLine(commandinresult);
string commandExec = commandBuild.ToString().Replace("\r\n", "\n");
bool uploadFileStoped = false;
var runCommand = client.CreateCommand(commandExec);
var runClient = runCommand.BeginExecute((x) =>
{
var temp = curItemLBT.StopProcess;
if (curItemLBT.StopProcess)
{
if (!uploadFileStoped)
{
try
{
uploadFileStoped = true;
showWindow = false;
client.Disconnect();
//return $"Прервано выполнение {command}";
}
catch (Exception)
{
}
}
}
});
string result = runCommand.EndExecute(runClient);
client.Disconnect();
if (showWindow)
{
base.Dispatcher.BeginInvoke((Action)(() =>
{
SSHReportWindow window = new SSHReportWindow(this)
{
Owner = this,
Title = string.Format($"Команда SSH {command} на {nbNameOrIP}"),
Text = { Text = result },
SSHStatusBarText = { Text = string.Format($"Команда SSH {command} на {nbNameOrIP} выполнена.") }
};
this.Log(window.SSHStatusBarText.Text, false, false, "", false);
window.Show();
}));
}
}
}
catch (ArgumentException exception)
{
Log("Необходимо выбрать логин и пароль", true, true, exception.StackTrace, false);
}
catch (Exception exception)
{
this.Log(exception.Message, true, true, exception.StackTrace, false);
}
//});
}));
runThread.Start();
//while (!curItemLBT.StopProcess || (runThread.ThreadState != System.Threading.ThreadState.Stopped) || (runThread.ThreadState != System.Threading.ThreadState.Aborted))
//{
// if (!(runThread.ThreadState == System.Threading.ThreadState.Stopped))
// {
// runThread.Abort();
// }
//}
}
static async Task runAsync(string[] args)
{
var config = System.IO.File.ReadAllLines("client.config");
var connectionInfo = new ConnectionInfo(config[2],
config[3],
new PasswordAuthenticationMethod(config[3], config[4]));
var sshClient = new SshClient(connectionInfo);
var sshCommand = config[5];
var client = new TelegramClient(int.Parse(config[0]), config[1]);
await client.ConnectAsync();
if (!client.IsUserAuthorized())
{
Console.WriteLine("Please enter your phone number");
var number = Console.ReadLine();
var hash = await client.SendCodeRequestAsync(number);
Console.WriteLine("Enter the code you recieved from Telegram");
var code = Console.ReadLine();
TLUser user = null;
try
{
user = await client.MakeAuthAsync(number, hash, code);
}
catch (CloudPasswordNeededException)
{
var password = await client.GetPasswordSetting();
Console.WriteLine("Enter your 2FA Password");
var password_str = Console.ReadLine();
user = await client.MakeAuthWithPasswordAsync(password, password_str);
}
}
var result = await client.GetContactsAsync();
var userToSendTo = result.Users
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.Username == "browny99");
var logPeer = new TLInputPeerUser()
{
UserId = userToSendTo.Id
};
await client.SendMessageAsync(logPeer, "Started monitoring");
string UserNameToSendMessage = "@corgigroupagreebot";
var unameResult = await client.SearchUserAsync(UserNameToSendMessage);
var userByName = unameResult.Users
.Where(x => x.GetType() == typeof(TLUser))
.OfType <TLUser>()
.FirstOrDefault(x => x.Username == UserNameToSendMessage.TrimStart('@'));
int retryCounter = 0;
while (!System.IO.File.Exists("cancel.wjdummy"))
{
try
{
TLInputPeerUser botToCheck = new TLInputPeerUser()
{
UserId = userByName.Id, AccessHash = (long)userByName.AccessHash
};
await client.SendMessageAsync(botToCheck, "/start");
await Task.Delay(TimeSpan.FromSeconds(30));
TLAbsMessages history = await client.GetHistoryAsync(botToCheck, limit : 1);
TLMessagesSlice slice = (TLMessagesSlice)history;
var message = ((TLMessage)slice.Messages.ElementAt(0));
if (message.Out == false && message.Message.StartsWith("Hey, good to see you again"))
{
var request = new TLRequestReadHistory();
request.Peer = botToCheck;
await client.SendRequestAsync <TLAffectedMessages>(request);
retryCounter = 0;
}
else
{
retryCounter++;
await client.SendMessageAsync(logPeer, "30 sec unresponsive");
}
if (retryCounter > 5)
{
sshClient.Connect();
var res = sshClient.CreateCommand(sshCommand).Execute();
sshClient.Disconnect();
await client.SendMessageAsync(logPeer, "Restarted server\n\n" + res);
await Task.Delay(TimeSpan.FromSeconds(90));
retryCounter = 0;
}
} catch (Exception e)
{
try
{
await client.SendMessageAsync(logPeer, "Error: \n" + e.ToString());
} catch (Exception ex)
{
Console.WriteLine($"ERROR\n\n{e}\n{ex}\n\nENDERROR");
return;
}
}
}
}