CreateCommand() public method

Creates the command to be executed.
Client is not connected.
public CreateCommand ( string commandText ) : SshCommand
commandText string The command text.
return SshCommand
コード例 #1
0
ファイル: SshListener.cs プロジェクト: sujathkumar/legacypgs
        /// <summary>
        /// ListenPort
        /// </summary>
        /// <returns></returns>
        public string ListenPort()
        {
            Constants.log.Info("Entering SshListener ListenPort Method!");
            string response = string.Empty;

            if (_sshClient == null && _connInfo == null)
            {
                Constants.log.Info("Calling SshListener InitializeListener Method!");
                InitializeListener();
            }

            try
            {
                _sshClient = new SshClient(_connInfo);
                _sshClient.Connect();
                response = _sshClient.CreateCommand(this.Command).Execute();
            }
            catch (Exception ex)
            {
                Constants.log.Error(ex.Message);
                response = ex.Message;
            }

            Constants.log.Info("Exiting SshListener ListenPort Method!");
            return response;
        }
コード例 #2
0
ファイル: PublicKeyTests.cs プロジェクト: mykquayce/Helpers
    public void ConnectionTests(int count, int pause)
    {
        var regex = new Regex(@"^\d+\s[\d\w:]+\s[\d\.]+\s.+?\s.+?$", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.Multiline);

        Renci.SshNet.SshClient client;
        {
            var path = Concrete.Client.FixPath(_config.PathToPrivateKey !);
            using var keyFile = new Renci.SshNet.PrivateKeyFile(path);
            client            = new Renci.SshNet.SshClient(_config.Host, _config.Port, _config.Username, keyFile);
        }

        client.Connect();

        while (count-- > 0)
        {
            string output;
            {
                using var command      = client.CreateCommand("cat /tmp/dhcp.leases", Encoding.UTF8);
                command.CommandTimeout = TimeSpan.FromSeconds(1);
                output = command.Execute();
            }

            Assert.NotNull(output);
            Assert.NotEmpty(output);
            Assert.Matches(regex, output);

            Thread.Sleep(pause);
        }

        client.Disconnect();
        client.Dispose();
    }
コード例 #3
0
        private static String ExecuteCommand(SshClient sshClient, String command)
        {
            if (!sshClient.IsConnected)
                sshClient.Connect();

            return sshClient.CreateCommand(command).Execute();
        }
コード例 #4
0
        public SshCommand CreateSSHCommand(string userCommandText)
        {
            InternalConnect(_sshDeltaCopyOptions.Host, _sshDeltaCopyOptions.Port, _sshDeltaCopyOptions.Username, _sshDeltaCopyOptions.Password, _sshDeltaCopyOptions.DestinationDirectory);

            var commandText = $"cd \"{_sshDeltaCopyOptions.DestinationDirectory}\";{userCommandText}";

            return(_sshClient.CreateCommand(commandText));
        }
コード例 #5
0
        public static String getPath(String username, String password, String host)
        {
            var ssh = new Renci.SshNet.SshClient(host, username, password);

            try
            {
                ssh.Connect();
            }
            catch (Exception error)
            {
                Console.WriteLine("Couldn't connect to iPhone");
            }

            if (ssh.IsConnected)
            {
                Console.WriteLine("\nConnected to iPhone (" + host + ")");
            }

            else
            {
                Console.WriteLine("Could't connect to iPhone");
            }

            Console.WriteLine("\nfind /var/mobile/Containers -iname pw.dat");
            var cmd    = ssh.CreateCommand("find /var/mobile/Containers -iname pw.dat");            //  very long list
            var asynch = cmd.BeginExecute(delegate(IAsyncResult ar)
            {
                Console.WriteLine("\nDisconnected from iPhone.");
            }, null);

            var reader = new StreamReader(cmd.OutputStream);

            String output = "";

            while (!asynch.IsCompleted)
            {
                var result = reader.ReadToEnd();
                if (string.IsNullOrEmpty(result))
                {
                    continue;
                }
                Console.Write("\n> " + result);
                output = result;
            }
            cmd.EndExecute(asynch);

            String path = output.Substring(0, 76);

            Console.WriteLine(path);


            reader.Close();
            ssh.Disconnect();


            return(path);
        }
コード例 #6
0
        //выполнение команд с новым клиентом
        private void Execute(SshClient client, string command)
        {
            using (var cmd = client.CreateCommand(command))
            {
                cmd.Execute();
                _listResult.Add(cmd.Result);
                if (cmd.Error.Length != 0)
                {
                    _listError.Add(cmd.Error);
                }

            }
        }
コード例 #7
0
ファイル: Program.cs プロジェクト: tiernano/ubntmpowerreader
        static void Main(string[] args)
        {
            string servers = ConfigurationManager.AppSettings["servers"];
            string username = ConfigurationManager.AppSettings["username"];
            string password = ConfigurationManager.AppSettings["password"];
            foreach (string server in servers.Split(','))
            {
                ConnectionInfo ConnNfo = new ConnectionInfo(server, 22, username,
                    new AuthenticationMethod[]{
                        // Pasword based Authentication
                        new PasswordAuthenticationMethod(username,password)
                    }
                    );

                string[] items = { "active_pwr", "energy_sum", "v_rms", "pf","enabled" };

                using (var sshclient = new SshClient(ConnNfo))
                {
                    Console.WriteLine("Connecting to {0}", server);
                    sshclient.Connect();
                    // quick way to use ist, but not best practice - SshCommand is not Disposed, ExitStatus not checked...
                    foreach (string itemName in items)
                    {
                        for (int port = 1; port < 7; port++)
                        {
                            string outputFileName = string.Format("{0}-{1}-{2}.txt", server, itemName, port);
                            Console.WriteLine(string.Format("{0}{1}", itemName, port));
                            string result = sshclient.CreateCommand(string.Format("cat /proc/power/{0}{1}", itemName, port)).Execute();
                            if (!File.Exists(outputFileName))
                            {
                                using (var writer = File.CreateText(outputFileName))
                                {
                                    writer.WriteLine(string.Format("{0}, {1}", DateTime.Now.Ticks, result));
                                }
                            }
                            else
                            {
                                using (var writer = File.AppendText(outputFileName))
                                {
                                    writer.WriteLine(string.Format("{0}, {1}", DateTime.Now.Ticks, result));
                                }
                            }
                            Console.WriteLine(result);
                        }
                    }
                    sshclient.Disconnect();
                }
            }
        }
コード例 #8
0
    public async Task Async(string commandText, string expected)
    {
        using var command = _sut.CreateCommand(commandText);

        command.CommandTimeout = TimeSpan.FromSeconds(5);

        var task = Task.Factory.FromAsync <string>(
            beginMethod: (callback, state) => command.BeginExecute(callback, state),
            endMethod: result => command.EndExecute(result),
            state: commandText);

        var actual = await task;

        Assert.NotNull(actual);
        Assert.NotEmpty(actual);
        Assert.Matches(expected, actual);
    }
コード例 #9
0
ファイル: Ssh.cs プロジェクト: rajeshwarn/CycriptGUI
        public static string[] MakeRequest(SshClient client, string command)
        {
            SshCommand sshCommand = client.CreateCommand(command);
            var asynch = sshCommand.BeginExecute();

            StreamReader streamReader = new StreamReader(sshCommand.OutputStream);
            string response = "";
            while (!asynch.IsCompleted)
            {
                string result = streamReader.ReadToEnd();
                if (result != "")
                {
                    response += result;
                }
            }

            return response.TrimEnd('\r', '\n').Split('\n');
        }
コード例 #10
0
ファイル: MainWindow.xaml.cs プロジェクト: hen31/SpinDP
        private void Button_Click_3(object sender, RoutedEventArgs e)
        {
            Instellingen inst = new Instellingen();
            ConnectionInfo connectionInfo = new PasswordConnectionInfo(inst.ip, "pi", "idpgroep5");
             ssh = new SshClient(connectionInfo);

                ssh.Connect();
                var cmd = ssh.CreateCommand("./startSpinOS.sh");   //  very long list
                var asynch = cmd.BeginExecute();
                System.Threading.Thread.Sleep(20000);
                ssh.Disconnect();

            /*SshStream ssh = new SshStream("192.168.10.1", "pi", "idpgroep5");
            //Set the end of response matcher character
            ssh.Prompt = "#";
            //Remove terminal emulation characters
            ssh.RemoveTerminalEmulationCharacters = true;
            //Writing to the SSH channel
            ssh.Write("./startSpinOS.sh");*/
        }
コード例 #11
0
ファイル: SSHController.cs プロジェクト: aboyce/RasPi-Control
        /// <summary>
        /// Sends a command with or without arguments to a remote SSH server, and then returns the response. (Ensure the response will be a single line with no required input!)
        /// </summary>
        /// <param name="address">The address to connect to</param>
        /// <param name="username">The username to use to connect with</param>
        /// <param name="password">The password for the username to connect to</param>
        /// <param name="scriptName">The name of the script to run</param>
        /// <param name="arguments">The arguments (if any) to send after the scriptName</param>
        /// <returns>Either the response from the remote client (prefixed with 'P'), or the error that occurred (prefixed with 'F')</returns>
        public static string SendCommand(string address, string username, string password, string scriptName, string arguments = "")
        {
            string response = string.Empty;

            try
            {
                SshClient client = new SshClient(address, username, password);
                client.Connect();
                if (client.IsConnected)
                {
                    SshCommand command = client.CreateCommand(string.Format("{0} {1}", scriptName, arguments));
                    command.Execute();
                    response = command.Result;
                }
                client.Disconnect();
                client.Dispose();
            }
            catch (Exception exception)
            {
                return "F" + exception.Message; // F = Fail
            }

            return "P" + response; // P = Pass
        }
コード例 #12
0
		private void BeginService()
		{
			_client = new SshClient(Host, UserName, Password);
			_client.Connect();
            _client.RunCommand("sudo pkill mono");
			var call = string.Format("cd {0}", _homePiBuildindicatronServer);
			const string commandText = "sudo mono BuildIndicatron.Server.exe";
			var text = call + " && " + commandText;
			_log.Info("Starting command:" + text);
			_runCommand = _client.CreateCommand(text);
			_beginExecute = _runCommand.BeginExecute();
			streamReader = new StreamReader(_runCommand.OutputStream);
			WaitFor("Running", 6000).Wait();
		}
コード例 #13
0
ファイル: SshCommand.cs プロジェクト: waffle-iron/nequeo
 /// <summary>
 /// Initializes a new instance of the <see cref="SshCommand"/> class.
 /// </summary>
 /// <param name="sshClient">The SSH client.</param>
 /// <param name="commandText">The command text.</param>
 /// <param name="encoding">The encoding to use for the results.</param>
 /// <exception cref="ArgumentNullException">Either <paramref name="commandText"/> is null.</exception>
 internal SshCommand(Renci.SshNet.SshClient sshClient, string commandText, Encoding encoding)
 {
     _sshCommand = sshClient.CreateCommand(commandText, encoding);
 }
コード例 #14
0
ファイル: Program.cs プロジェクト: SvenDowideit/mono-test
        public static void dir(string indir, string outdir)
        {
            string username = @"docker";
            // Setup Credentials and Server Information
            string dockerHost = @"192.168.119.129";
            ConnectionInfo ConnNfo = new ConnectionInfo(dockerHost, 22, username,
                new AuthenticationMethod[]{

                // Password based Authentication
                new PasswordAuthenticationMethod(username, @"tcuser"),

                // Key Based Authentication (using keys in OpenSSH Format)
                //new PrivateKeyAuthenticationMethod(username,new PrivateKeyFile[]{
                //    new PrivateKeyFile(@"..\openssh.key","passphrase")
                //}),
                }
            );
            //string dir = System.IO.Path.GetDirectoryName(outfile);
            // Execute a (SHELL) Command - prepare upload directory
            using (var sshclient = new SshClient(ConnNfo))
            {
                sshclient.Connect();
            //                using (var cmd = sshclient.CreateCommand(@"ls /etc"))
                using (var cmd = sshclient.CreateCommand(@"mkdir -p " + outdir + @" && chmod +rw " + outdir))
                {
                    string output = cmd.Execute();
                    Console.WriteLine("Command>" + cmd.CommandText);
                    Console.WriteLine(output);
                    Console.WriteLine(cmd.Result);
                    Console.WriteLine("Return Value = {0}", cmd.ExitStatus);
                }
                sshclient.Disconnect();
            }
            // Upload A File
            using (var scp = new ScpClient(ConnNfo))
            {
                scp.Connect();
                scp.Upload(new System.IO.DirectoryInfo(indir), outdir);
                scp.Disconnect();
            }
        }
コード例 #15
0
ファイル: linuxhostinfo.cs プロジェクト: bridgewell/Hict
 private IEnumerable<statistics> GetDMI(SshClient client)
 {
     var cmdresult = client.CreateCommand("dmesg |grep DMI:").Execute().Split(new char[] { ':' });
     if (cmdresult.Length == 2)
     {
         yield return new statistics()
         {
             type = StatisticsType.DMI.ToString(),
             val = cmdresult[1],
         };
     }
 }
コード例 #16
0
        private string MikrotikExportCompact(string MikrotikIP, int MikrotikSSHPort, string MikrotikUser, string MikrotikPassword)
        {
            ConnectionInfo sLogin = new PasswordConnectionInfo(MikrotikIP, MikrotikSSHPort, MikrotikUser, MikrotikPassword);
            SshClient sClient = new SshClient(sLogin);
            sClient.Connect();

            SshCommand appStatCmd = sClient.CreateCommand("export compact");
            appStatCmd.Execute();

            sClient.Disconnect();
            sClient.Dispose();

            return appStatCmd.Result;
        }
コード例 #17
0
ファイル: linuxhostinfo.cs プロジェクト: bridgewell/Hict
 private IEnumerable<statistics> GetCPUCores(SshClient client)
 {
     var cmdresult = client.CreateCommand("cat /proc/cpuinfo | grep processor").Execute();
     var lines = cmdresult.Split(new char[] { '\r', '\n' }).Where(l => l.Trim().Length > 0);
     yield return new statistics()
     {
         type = StatisticsType.CPUCores.ToString(),
         val = lines.Count().ToString(),
     };
 }
コード例 #18
0
ファイル: linuxhostinfo.cs プロジェクト: bridgewell/Hict
 private IEnumerable<statistics> GetUpSeconds(SshClient client)
 {
     var cmdresult = client.CreateCommand("cat /proc/uptime").Execute().Split(new char[] {' '});
     double sec;
     if (double.TryParse(cmdresult[0], out sec))
     {
         yield return new statistics()
         {
             type = StatisticsType.UpSeconds.ToString(),
             val = sec.ToString(),
         };
     }
 }
コード例 #19
0
ファイル: linuxhostinfo.cs プロジェクト: bridgewell/Hict
        private IEnumerable<statistics> GetMemInfo(SshClient client)
        {
            var cmdresult = client.CreateCommand("cat /proc/meminfo").Execute();
            var lines = cmdresult.Split(new char[] { '\r', '\n' });
            var infos = lines.Select(l =>
            {
                var data = l.Split(new char[] { ':' });
                if (data.Length == 2)
                    return new Tuple<string, string>(data[0], data[1]);
                else
                    return new Tuple<string, string>(data[0], string.Empty);
            }).ToDictionary(k => k.Item1);

            Func<string, double> convertToDouble = str =>
            {
                if (str.EndsWith(" kB"))
                    return Convert.ToDouble(str.Substring(0, str.Length - 3))*1000;
                else
                    return 0;
            };

            Tuple<string,string> d;
            if (infos.TryGetValue("MemTotal", out d))
                yield return new statistics()
                {
                    type = StatisticsType.MemInfoTotal.ToString(),
                    val = convertToDouble(d.Item2).ToString(),
                };
            if (infos.TryGetValue("MemFree", out d))
                yield return new statistics()
                {
                    type = StatisticsType.MemInfoFree.ToString(),
                    val = convertToDouble(d.Item2).ToString(),
                };
        }
コード例 #20
0
ファイル: linuxhostinfo.cs プロジェクト: bridgewell/Hict
        private IEnumerable<statistics> GetMachineType(SshClient client)
        {
            var cmdresult = client.CreateCommand("uname -sr").Execute();

            yield return new statistics() {
                type = StatisticsType.MachineType.ToString(),
                val = cmdresult,
            };
        }
コード例 #21
0
ファイル: linuxhostinfo.cs プロジェクト: bridgewell/Hict
        private IEnumerable<statistics> GetInterfaceIP(SshClient client)
        {
            var cmdresult = client.CreateCommand("ifconfig").Execute();
            var lines = cmdresult.Split(new char[] { '\r', '\n' });
            var regexlist = linuxregex;
            string currenteth = string.Empty;
            foreach (var l in lines)
            {
                if (l.Contains("Link encap:"))
                {
                    currenteth = l.Split(' ').FirstOrDefault();
                    continue;
                }
                if (l.Contains(": flags="))
                {
                    currenteth = l.Split(':').FirstOrDefault();
                    regexlist = coreosregex;
                    continue;
                }

                if (currenteth.Length == 0)
                    continue;

                var foundmatch = regexlist.Select(r => Tuple.Create(r , r.regex.Match(l))).Where(r => r.Item2.Success).FirstOrDefault();

                if (foundmatch == null)
                    continue;

                foreach (var rd in foundmatch.Item1.regdata)
                {
                    var val = foundmatch.Item2.Groups[rd.Item2].Value;
                    if (rd.Item1 == StatisticsType.InterfaceIp)
                    {
                        if (val == "127.0.0.1")
                            continue;
                    }

                    if (string.IsNullOrWhiteSpace(val))
                        continue;

                    yield return new statistics() {
                        type = rd.Item1.ToString(),
                        val = val,
                        category = currenteth,
                    };
                }
            }
        }
コード例 #22
0
        /// <summary>
        /// Runs a command on the specified PlanetLab node.
        /// </summary>
        /// <param name="state">The manager state.</param>
        /// <param name="node">The PlanetLab node state.</param>
        /// <param name="command">The PlanetLab command.</param>
        /// <param name="set">The command parameter set.</param>
        /// <param name="sshClient">The SSH client.</param>
        private void OnRunCommand(PlManagerState state, PlManagerNodeState node, PlCommand command, int set, SshClient sshClient)
        {
            // Raise the command started event.
            if (null != this.CommandStarted) this.CommandStarted(this, new PlManagerCommandEventArgs(state, node.Node, command, set));
            try
            {
                // Compute the command text.
                string commandText = set >= 0 ? command.GetCommand(set) : command.Command;

                // The number of subcommands.
                int success = 0;
                int fail = 0;

                // Divide the command into subcommands.
                string[] subcommands = commandText.Split(PlManager.subcommandSeparators, StringSplitOptions.RemoveEmptyEntries);

                // For all subcommands.
                foreach (string subcommand in subcommands)
                {
                    // If the operation has been paused, wait for resume.
                    if (state.IsPaused)
                    {
                        state.WaitPause();
                    }
                    // If the operation has been canceled, return.
                    if (state.IsStopped)
                    {
                        // Raise the canceled event.
                        if (null != this.CommandCanceled) this.CommandCanceled(this, new PlManagerCommandEventArgs(state, node.Node, command, set));
                        // Return.
                        return;
                    }

                    // If the subcommand is empty, continue to the next subcommand.
                    if (string.IsNullOrWhiteSpace(subcommand)) continue;

                    // Create a new SSH command.
                    using (SshCommand sshCommand = sshClient.CreateCommand(subcommand))
                    {
                        try
                        {
                            // The command duration.
                            TimeSpan duration;
                            // The retry count.
                            int retry = 0;

                            do
                            {
                                // The start time.
                                DateTime startTime = DateTime.Now;

                                // Execute the command.
                                sshCommand.Execute();

                                // Compute the command duration.
                                duration = DateTime.Now - startTime;
                            }
                            while ((retry++ < state.Slice.CommandRetries) && (sshCommand.ExitStatus != 0));

                            // Create a new command state.
                            PlManagerSubcommandState subcommandState = new PlManagerSubcommandState(node, sshCommand, duration, retry - 1);

                            // Increment the number of successful subcommands.
                            success++;

                            // Add the subcommand.
                            node.AddSubcommand(subcommandState);

                            // Raise a subcommand success event.
                            if (null != this.SubcommandSuccess) this.SubcommandSuccess(this, new PlManagerSubcommandEventArgs(state, node.Node, command, set, subcommandState));
                        }
                        catch (Exception exception)
                        {
                            // Create a new subcommand state.
                            PlManagerSubcommandState subcommandState = new PlManagerSubcommandState(node, sshCommand, exception);

                            // Increment the number of failed subcommands.
                            fail++;

                            // Add the subcommand.
                            node.AddSubcommand(subcommandState);

                            // Raise a subcommand fail event.
                            if (null != this.SubcommandFail) this.SubcommandFail(this, new PlManagerSubcommandEventArgs(state, node.Node, command, set, exception));
                        }
                    }
                }

                // Raise a command completed event.
                if (null != this.CommandFinishedSuccess) this.CommandFinishedSuccess(this, new PlManagerCommandEventArgs(state, node.Node, command, set, success, fail));
            }
            catch (Exception exception)
            {
                // Raise a command completed event.
                if (null != this.CommandFinishedFail) this.CommandFinishedFail(this, new PlManagerCommandEventArgs(state, node.Node, command, set, exception));
            }
        }
コード例 #23
0
        private void RunCommand(SshClient sshClient, string command)
        {
            using (var sshCommand = sshClient.CreateCommand(command))
            {
                sshCommand.Execute();

                if (!string.IsNullOrEmpty(sshCommand.Result))
                    InstallationProgress.ProgressText += sshCommand.Result;

                if (!string.IsNullOrEmpty(sshCommand.Error) && sshCommand.ExitStatus != 0)
                    throw new Exception(sshCommand.Error);
            }
        }
コード例 #24
0
ファイル: linuxhostinfo.cs プロジェクト: bridgewell/Hict
        private IEnumerable<statistics> GetVolInfo(SshClient client)
        {
            var cmdresult = client.CreateCommand("df -P").Execute();
            var lines = cmdresult.Split(new char[] { '\r', '\n' });
            var infos = lines
                .Where(l => l.Trim().Length > 0)
                .Select(l => l.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)).Skip(1);

            foreach (var l in infos)
            {
                if (l[0].StartsWith("/dev") == false)
                    continue;

                yield return new statistics()
                {
                    type = StatisticsType.VolumeTotal.ToString(),
                    category = l[0],
                    val = l[1],
                };

                yield return new statistics()
                {
                    type = StatisticsType.VolumeUsage.ToString(),
                    category = l[0],
                    val = l[2],
                };
            }
        }
コード例 #25
0
ファイル: linuxhostinfo.cs プロジェクト: bridgewell/Hict
        private IEnumerable<statistics> GetCpuMemUsage(SshClient client)
        {
            var pscmd = client.CreateCommand("ps ax -o %cpu,%mem,command |grep -v migration");
            var cmdresult = pscmd.Execute();
            var lines = cmdresult.Split(new char[] { '\r', '\n' }).Skip(1).ToList();
            var infos = lines.Select(l =>
            {
                var data = l.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                    .Where(s => s.Trim() != string.Empty)
                    .Select(s => { double d = 0; double.TryParse(s, out d); return d; }).ToList();
                if (data.Count >= 2)
                    return new Tuple<double, double>(data[0], data[1]);
                else
                    return new Tuple<double, double>(0, 0);
            }).ToList();

            var cpu = infos.Sum(d => d.Item1);
            var mem = infos.Sum(d => d.Item2);

            yield return new statistics()
            {
                type = StatisticsType.CPUUsage.ToString(),
                val = cpu.ToString(),
            };

            yield return new statistics()
            {
                type = StatisticsType.MEMUsage.ToString(),
                val = mem.ToString(),
            };
        }
コード例 #26
0
ファイル: Code.cs プロジェクト: shovelheadfxe/DevLab
        public static void SSHTest()
        {
            string[] list;

            ConnectionInfo ConnNfo = new ConnectionInfo("10.26.2.136", 22, "root",
               new AuthenticationMethod[]{

                // Pasword based Authentication
                new PasswordAuthenticationMethod("root","adminadmin_2")

                // Key Based Authentication (using keys in OpenSSH Format)
                //new PrivateKeyAuthenticationMethod("username",new PrivateKeyFile[]{
                //    new PrivateKeyFile(@"..\openssh.key","passphrase")
                //}
               });

            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());
                string output = sshclient.CreateCommand("cd /data1/strongmail/log && find strongmail-monitor* -maxdepth 1 -mtime -1").Execute();

                list = output.Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);

                foreach (string file in list)
                {
                    Console.WriteLine("File: " + file);
                }

                sshclient.Disconnect();
            }

            Console.Write("Attempt to download file.");
            // Upload A File
            using (var sftp = new SftpClient(ConnNfo))
            {

                sftp.Connect();
                sftp.ChangeDirectory("/data1/strongmail/log");

                foreach (string file in list)
                {
                    string fullPath = @"D:\Temp\StrongView\" + file;

                    var x = sftp.Get(file);
                    byte[] fileBytes = new byte[x.Length];

                    using (var dwnldfileStream = new System.IO.MemoryStream(fileBytes))
                    {

                        sftp.DownloadFile(file, dwnldfileStream);
                        //System.IO.File.WriteAllBytes(@"d:\temp\strongview\bytes\" + file, fileBytes);

                        //var xmlr = System.Xml.XmlReader.Create(dwnldfileStream);

                        //while (xmlr.Read()) {
                        //    if (xmlr.NodeType.Equals(System.Xml.XmlNodeType.Element) && xmlr.Name.Equals("QueueInfo")) {
                        //        string processid = xmlr.GetAttribute("PID");
                        //        while(!xmlr.)
                        //    }

                        //}

                        string text = ConnNfo.Encoding.GetString(fileBytes);
                        XDocument doc = XDocument.Parse("<root>" + text + "</root>");
                        var smtpQueue = doc.Descendants("QueueInfo").Where(xx => xx.Element("Protocol").Value.Equals("SMTP"));
                        var serverInfo = doc.Descendants("ServerInfo");

                        var wrtr = doc.CreateWriter();

                        System.Text.StringBuilder sb = new System.Text.StringBuilder();

                        using (System.Xml.XmlWriter wr = System.Xml.XmlWriter.Create(sb, new System.Xml.XmlWriterSettings() { ConformanceLevel = System.Xml.ConformanceLevel.Fragment }))
                        {

                            wr.WriteStartElement("root");
                            serverInfo.First().WriteTo(wr);

                            foreach (XElement xl in smtpQueue)
                            {
                                xl.WriteTo(wr);
                            }

                            wr.WriteEndElement();
                        }
                        string PID = smtpQueue.Attributes().First().Value.ToString();

                        System.IO.File.WriteAllText(@"d:\temp\strongview\docs\" + PID + ".xml", sb.ToString());

                    }

                }

                sftp.Disconnect();
            }
            Console.WriteLine("Done!");
            //Console.ReadKey();
        }
コード例 #27
0
        void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            //			var stringcommand = "echo 'echo '\"'\"'\t<option value=\"511\">Compilance Test</option>\r\n\t<option value=\"32\">Argentina</option>\r\n\t<option value=\"51\">Armenia</option>\r\n\t<option value=\"533\">Aruba</option>\r\n\t<option value=\"36\">Australia</option>\r\n\t<option value=\"40\">Austria</option>\r\n\t<option value=\"31\">Azerbaijan</option>\r\n\t<option value=\"48\">Bahrain</option>\r\n\t<option value=\"52\">Barbados</option>\r\n\t<option value=\"112\">Belarus</option>\r\n\t<option value=\"56\">Belgium</option>\r\n\t<option value=\"84\">Belize</option>\t\r\n\t<option value=\"68\">Bolivia</option>\r\n\t<option value=\"70\">Bosnia and Herzegovina</option>\r\n\t<option value=\"76\">Brazil</option>\r\n\t<option value=\"96\">Brunei Darussalam</option>\r\n\t<option value=\"100\">Bulgaria</option>\r'>/etc/persistent/rc.poststart";
            //			var stringcommand1 = "echo '\t<option value=\"116\">Cambodia</option>\r\n\t<option value=\"124\">Canada</option>\r\n\t<option value=\"152\">Chile</option>\r\n\t<option value=\"156\">China</option>\r\n\t<option value=\"170\">Colombia</option>\r\n\t<option value=\"188\">Costa Rica</option>\r\n\t<option value=\"191\">Croatia</option>\r\n\t<option value=\"196\">Cyprus</option>\r\n\t<option value=\"203\">Czech Republic</option>\r'>>/etc/persistent/rc.poststart";
            //			var stringcommand2 = "echo '\t<option value=\"208\">Denmark</option>\r\n\t<option value=\"214\">Dominican Republic</option>\r\n\t<option value=\"218\">Ecuador</option>\r\n\t<option value=\"818\">Egypt</option>\r\n\t<option value=\"222\">El Salvador</option>\r\n\t<option value=\"233\">Estonia</option>\r\n\t<option value=\"246\">Finland</option>\r\n\t<option value=\"250\">France</option>\r'>>/etc/persistent/rc.poststart";
            //			var stringcommand3 = "echo '\t<option value=\"268\">Georgia</option>\r\n\t<option value=\"276\">Germany</option>\r\n\t<option value=\"300\">Greece</option>\r\n\t<option value=\"304\">Greenland</option>\r\n\t<option value=\"308\">Grenada</option>\r\n\t<option value=\"316\">Guam</option>\r\n\t<option value=\"320\">Guatemala</option>\r\n\t<option value=\"332\">Haiti</option>\r\n\t<option value=\"340\">Honduras</option>\r\n\t<option value=\"344\">Hong Kong</option>\r\n\t<option value=\"348\">Hungary</option>\r'>>/etc/persistent/rc.poststart";
            //			var stringcommand4 = "echo '\t<option value=\"352\">Iceland</option>\r\n\t<option value=\"356\">India</option>\r\n\t<option value=\"360\">Indonesia</option>\r\n\t<option value=\"368\">Iraq</option>\r\n\t<option value=\"372\">Ireland</option>\r\n\t<option value=\"376\">Israel</option>\r\n\t<option value=\"380\">Italy</option>\r\n\t<option value=\"388\">Jamaica</option>\r\n\t<option value=\"400\">Jordan</option>\r\n\t<option value=\"404\">Kenya</option>\r\n\t<option value=\"410\">Korea Republic</option>\r\n\t<option value=\"414\">Kuwait</option>\r'>>/etc/persistent/rc.poststart";
            //			var stringcommand5 = "echo '\t<option value=\"428\">Latvia</option>\r\n\t<option value=\"422\">Lebanon</option>\r\n\t<option value=\"438\">Liechtenstein</option>\r\n\t<option value=\"440\">Lithuania</option>\r\n\t<option value=\"442\">Luxembourg</option>\r\n\t<option value=\"446\">Macau</option>\r\n\t<option value=\"807\">Macedonia</option>\r\n\t<option value=\"458\">Malaysia</option>\r\n\t<option value=\"470\">Malta</option>\r\n\t<option value=\"484\">Mexico</option>\r\n\t<option value=\"492\">Monaco</option>\r'>>/etc/persistent/rc.poststart";
            //			var stringcommand6 = "echo '\t<option value=\"499\">Montenegro</option>\r\n\t<option value=\"504\">Morocco</option>\r\n\t<option value=\"524\">Nepal</option>\r\n\t<option value=\"528\">Netherlands</option>\r\n\t<option value=\"530\">Netherlands Antilles</option>\r\n\t<option value=\"554\">New Zealand</option>\r\n\t<option value=\"566\">Nigeria</option>\r\n\t<option value=\"578\">Norway</option>\r\n\t<option value=\"512\">Oman</option>\r\n\t<option value=\"586\">Pakistan</option>\r\n\t<option value=\"591\">Panama</option>\r\n\t<option value=\"598\">Papua New Guinea</option>\r\n\t<option value=\"604\">Peru</option>\r\n\t<option value=\"608\">Philippines</option>\r'>>/etc/persistent/rc.poststart";
            //			var stringcommand7 = "echo '\t<option value=\"616\">Poland</option>\r\n\t<option value=\"620\">Portugal</option>\r\n\t<option value=\"630\">Puerto Rico (U.S. territory)</option>\r\n\t<option value=\"634\">Qatar</option>\r\n\t<option value=\"642\">Romania</option>\r\n\t<option value=\"643\">Russia</option>\r\n\t<option value=\"646\">Rwanda</option>\r\n\t<option value=\"652\">Saint Barthelemy</option>\r\n\t<option value=\"682\">Saudi Arabia</option>\r\n\t<option value=\"688\">Serbia</option>\r\n\t<option value=\"702\">Singapore</option>\r\n\t<option value=\"703\">Slovakia</option>\r\n\t<option value=\"705\">Slovenia</option>\r\n\t<option value=\"710\">South Africa</option>\r\n\t<option value=\"724\">Spain</option>\r\n\t<option value=\"144\">Sri Lanka</option>\r'>>/etc/persistent/rc.poststart";
            //			var stringcommand8 = "echo '\t<option value=\"752\">Sweden</option>\r\n\t<option value=\"756\">Switzerland</option>\r\n\t<option value=\"158\">Taiwan</option>\r\n\t<option value=\"764\">Thailand</option>\r\n\t<option value=\"780\">Trinidad and Tobago</option>\r\n\t<option value=\"788\">Tunisia</option>\r\n\t<option value=\"792\">Turkey</option>\r\n\t<option value=\"804\">Ukraine</option>\r\n\t<option value=\"784\">United Arab Emirates</option>\r\n\t<option value=\"826\">United Kingdom</option>\r\n\t<option value=\"840\">United States</option>\r\n\t<option value=\"858\">Uruguay</option>\r\n\t<option value=\"860\">Uzbekistan</option>\r\n\t<option value=\"862\">Venezuela</option>\r\n\t<option value=\"704\">Viet Nam</option>'\"'\"'>/etc/ccodes.inc'>>/etc/persistent/rc.poststart";

            using (var sshclient = new SshClient (_ip, _user, _pwd)) {
                try {
                    sshclient.Connect ();

                    using (var cmd = sshclient.CreateCommand ("cat /etc/version")) {
                        cmd.Execute();
                        mensaje = "Version del Producto: " +  cmd.Result.TrimEnd() + "\n";
                    }

            //					using (var cmd = sshclient.CreateCommand (stringcommand))
            //						cmd.Execute ();
            //					using (var cmd = sshclient.CreateCommand (stringcommand1))
            //						cmd.Execute ();
            //					using (var cmd = sshclient.CreateCommand (stringcommand2))
            //						cmd.Execute ();
            //					using (var cmd = sshclient.CreateCommand (stringcommand3))
            //						cmd.Execute ();
            //					using (var cmd = sshclient.CreateCommand (stringcommand4))
            //						cmd.Execute ();
            //					using (var cmd = sshclient.CreateCommand (stringcommand5))
            //						cmd.Execute ();
            //					using (var cmd = sshclient.CreateCommand (stringcommand6))
            //						cmd.Execute ();
            //					using (var cmd = sshclient.CreateCommand (stringcommand7))
            //						cmd.Execute ();
            //					using (var cmd = sshclient.CreateCommand (stringcommand8))
            //						cmd.Execute ();

            //					using (var cmd = sshclient.CreateCommand ("chmod +x /etc/persistent/rc.poststart"))
            //						cmd.Execute ();
            //					using (var cmd = sshclient.CreateCommand ("cfgmtd -w -p /etc/"))
            //						cmd.Execute ();
            //					using (var cmd = sshclient.CreateCommand ("/etc/persistent/rc.poststart"))
            //						cmd.Execute ();

                    using (var cmd = sshclient.CreateCommand ("rm /etc/persistent/rc.poststart"))
                        cmd.Execute ();
                    using (var cmd = sshclient.CreateCommand ("touch /etc/persistent/ct"))
                        cmd.Execute ();
                    using (var cmd = sshclient.CreateCommand ("save"))
                        cmd.Execute ();

                    sshclient.Disconnect ();
                } catch {
                    throw new InvalidOperationException ("No se pudo conectar con el equipo.\nVerifique la direccion ip o las credenciales");
                }

            }
        }
コード例 #28
0
        private void gothroughlinux(string c, string username, string password)
        {

            System.Threading.Tasks.Task task_1 = new System.Threading.Tasks.Task(() =>
                        {
                            try
                            {
                                using (var client = new SshClient(c, username, password))
                                {
                                    try
                                    {
                                        string list_mftr = ""; string list_hw = ""; string list_sn = ""; long list_mem = 0;
                                        string list_os = ""; string list_osver = ""; string list_osmftr = ""; string list_osserial = ""; string list_osverno = "";
                                        string list_cpucount = ""; string list_cpucore = ""; string list_cpuspeed = "";
                                        bool not_has = true;
                                        client.ConnectionInfo.Timeout = TimeSpan.FromSeconds(5);
                                        client.Connect();

                                        var device_name = client.CreateCommand("/bin/hostname");
                                        device_name.CommandTimeout = TimeSpan.FromSeconds(2);
                                        device_name.Execute();

                                        string dev_name = device_name.Result.Trim();
                                        if (ignoreDomain.Checked) { dev_name = dev_name.Split('.')[0]; }
                                        foreach (string[] subList in all_the_values)
                                        {
                                            if (subList[0] == dev_name) { not_has = false; break; }
                                        }

                                        if (not_has)
                                        {
                                            var release = client.CreateCommand("/usr/bin/python -m platform");
                                            release.CommandTimeout = TimeSpan.FromSeconds(2);
                                            release.Execute();
                                            string prfx = "";
                                            if (username != "root") { prfx = "sudo "; }
                                            var manufacturer = client.CreateCommand(prfx + "/usr/sbin/dmidecode -s system-manufacturer");
                                            manufacturer.CommandTimeout = TimeSpan.FromSeconds(2);
                                            manufacturer.Execute();

                                            var hardware = client.CreateCommand(prfx + "/usr/sbin/dmidecode -s system-product-name");
                                            hardware.CommandTimeout = TimeSpan.FromSeconds(2);
                                            hardware.Execute();

                                            var serial_no = client.CreateCommand(prfx + "/usr/sbin/dmidecode -s system-serial-number");
                                            serial_no.CommandTimeout = TimeSpan.FromSeconds(2);
                                            serial_no.Execute();

                                            var ifconfig = client.CreateCommand("/sbin/ifconfig -a | grep -A 2 Ethernet");
                                            ifconfig.CommandTimeout = TimeSpan.FromSeconds(2);
                                            ifconfig.Execute();

                                            var meminfo = client.CreateCommand("grep MemTotal /proc/meminfo");
                                            meminfo.CommandTimeout = TimeSpan.FromSeconds(2);
                                            meminfo.Execute();

                                            var cpuinfo = client.CreateCommand(prfx + "/usr/sbin/dmidecode -s processor-frequency | grep MHz");
                                            cpuinfo.CommandTimeout = TimeSpan.FromSeconds(2);
                                            cpuinfo.Execute();

                                            var coreinfo = client.CreateCommand(prfx + "/usr/sbin/dmidecode -t processor | grep \"Core Count\" | head -1");
                                            coreinfo.CommandTimeout = TimeSpan.FromSeconds(2);
                                            coreinfo.Execute();

                                            client.Disconnect();

                                            string os = Regex.Split(release.Result, "-with-")[1].Split('-')[0];
                                            string osver = Regex.Split(release.Result, "-with-")[1].Split('-')[1];
                                            //string osverno = Regex.Split(release.Result, "-with-")[0];
                                            list_os = os; list_osver = osver; //list_osverno = osverno;
                                            string Mftr = manufacturer.Result.Trim().Replace("# SMBIOS implementations newer than version 2.6 are not\n# fully supported by this version of dmidecode.\n","");

                                            string[] strArray = new string[] { "VMware, Inc.", "Bochs", "KVM", "QEMU", "Microsoft Corporation", "Xen" };
                                            foreach (string m_s in strArray)
                                            {
                                                if (m_s == Mftr) { list_mftr = "virtual"; break; }

                                            }
                                            if (list_mftr != "virtual")
                                            {
                                                list_mftr = Mftr;
                                                list_hw = hardware.Result.Trim().Replace("# SMBIOS implementations newer than version 2.6 are not\n# fully supported by this version of dmidecode.\n", "");
                                                list_sn = serial_no.Result.Trim().Replace("# SMBIOS implementations newer than version 2.6 are not\n# fully supported by this version of dmidecode.\n", "");
                                            }

                                            string memory_total = meminfo.Result.Replace(" ", "").Replace("MemTotal:", "").Replace("kB", "");
                                            long mem3 = upper_power_of_two(Convert.ToInt64(memory_total) / 1024);
                                            list_mem = mem3;
                                            int cpucount = 0;
                                            decimal cspeed = 0.0m;
                                            string cpuspeed = "";
                                            using (StringReader reader = new StringReader(cpuinfo.Result))
                                            {
                                                string line = string.Empty;
                                                do
                                                {
                                                    line = reader.ReadLine();
                                                    if (line != null)
                                                    {
                                                        cpucount += 1;
                                                        cpuspeed = Regex.Split(line, "MHz")[0].Trim();
                                                        cspeed = Convert.ToDecimal(cpuspeed) / 1000;
                                                    }

                                                } while (line != null);
                                            }
                                            string cpucores = coreinfo.Result.Replace("Core Count: ", "").Trim();
                                            if (cpucount > 0)
                                            {
                                                list_cpucount = cpucount.ToString(); list_cpuspeed = Convert.ToString(cspeed);
                                                if (cpucores != "") { list_cpucore = cpucores; }
                                            }
                                            all_the_values.Add(new string[] { dev_name, list_mftr, list_hw, list_sn, list_os, list_osver, list_osverno, list_osserial, list_osmftr, list_mem.ToString(), list_cpucount, list_cpucore, list_cpuspeed });

                                            string[] ifaces = Regex.Split(ifconfig.Result, "--\n");

                                            foreach (string iface in ifaces)
                                            {

                                                if (iface.Contains("inet addr"))
                                                {

                                                    string[] line = Regex.Split(iface, "\n");
                                                    string ipv4_address = "", tag = "", mac = "";
                                                    foreach (string ln in line)
                                                    {
                                                        if (ln.Contains("inet addr")) { ipv4_address = ln.Split(':')[1].Split(' ')[0]; }
                                                        if (ln.Contains("Ethernet")) { tag = ln.Split()[0]; mac = Regex.Split(ln, "HWaddr ")[1]; }


                                                    }
                                                    all_the_ip_values.Add(new string[] { ipv4_address, tag, mac, dev_name });


                                                }
                                                if (iface.Contains("inet6 addr"))
                                                {

                                                    string[] line = Regex.Split(iface, "\n");
                                                    string ipv6_address = "", tag = "", mac = "";
                                                    foreach (string ln in line)
                                                    {
                                                        if (ln.Contains("inet6 addr")) { ipv6_address = Regex.Split(ln, "addr: ")[1].Split('/')[0]; }
                                                        if (ln.Contains("Ethernet")) { tag = ln.Split()[0]; mac = Regex.Split(ln, "HWaddr ")[1]; }


                                                    }
                                                    all_the_ip6_values.Add(new string[] { ipv6_address, tag, mac, dev_name });

                                                }
                                            }
                                        }

                                    }
                                    catch (Exception ex)
                                    {
                                        //Console.WriteLine(ex.ToString());
                                        client.Disconnect();
                                        Trace.WriteLine(ex.ToString());
                                    }

                                }
                            }
                            catch (Exception ex) { Trace.WriteLine(ex.ToString()); }
            
                        }, tokenSource.Token);
            task_1.Start();
            task_1.ContinueWith(t => check_linux_progress());
        }
コード例 #29
0
ファイル: StreamCommand.cs プロジェクト: DynamicDevices/dta
        /// <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;
        }
コード例 #30
0
ファイル: Form1.cs プロジェクト: silverfoxy/Youtube-dl
 private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
 {
     try
     {
         using (var sshClient = new SshClient(SERVER_IP, SERVER_PORT, SERVER_USERNAME, SERVER_PASSWORD))
         {
             sshClient.Connect();
             toolStripStatusLabel1.Text = "Connected";
             SshCommand cmd;
             ComboboxItem selectedItem = (ComboboxItem)e.Argument;
             if (selectedItem.Name == "Default Quality")
             {
                 cmd = sshClient.CreateCommand(string.Format("youtube-dl --no-mtime --output '/var/www/html/%(title)s-%(id)s.%(ext)s' {0}", textBox_link.Text));
             }
             else
             {
                 cmd = sshClient.CreateCommand(string.Format("youtube-dl -f {0} --output '/var/www/html/%(title)s-%(id)s.%(ext)s' {1}", selectedItem.Value, textBox_link.Text));
             }
             toolStripStatusLabel1.Text = "Preparing to download";
             var async = cmd.BeginExecute(null, null);
             var reader = new StreamReader(cmd.OutputStream);
             while (!async.IsCompleted)
             {
                 Thread.Sleep(100);
                 var result = reader.ReadLine();
                 if (string.IsNullOrEmpty(result))
                 {
                     continue;
                 }
                 toolStripStatusLabel1.Text = result;
                 if (result.Contains("Destination"))
                 {
                     Video = (string)((string)result.Split(':').GetValue(1)).Split('/').GetValue(4);
                 }
                 if (result.Contains("has already been downloaded"))
                 {
                     Video = result;
                     int a = result.IndexOf("has already been downloaded");
                     Video = (string)result.Substring(12, result.IndexOf("has already been downloaded") - 12).Split('/').GetValue(3);
                 }
             }
             cmd.EndExecute(async);
             sshClient.Disconnect();
             toolStripStatusLabel1.Text = "Transfer to server completed.";
         }
     }
     catch (Exception)
     {
         toolStripStatusLabel1.Text = "Error occurred!";
     }
 }
コード例 #31
0
ファイル: Form1.cs プロジェクト: silverfoxy/Youtube-dl
 private void backgroundWorker2_DoWork(object sender, DoWorkEventArgs e)
 {
     try
     {
         using (var sshClient = new SshClient(SERVER_IP, SERVER_PORT, SERVER_USERNAME, SERVER_PASSWORD))
         {
             toolStripStatusLabel1.Text = "Connecting ...";
             sshClient.Connect();
             toolStripStatusLabel1.Text = "Connected";
             var cmd = sshClient.CreateCommand(string.Format("youtube-dl -F {0}", textBox_link.Text));
             toolStripStatusLabel1.Text = "Querying available video qualities";
             cmd.Execute();
             var result = cmd.Result;
             string[] items = result.Split('\n');
             bool here = false;
             qualities.Clear();
             for (int i = 0; i < items.Length; i++)
             {
                 if (here)
                 {
                     qualities.Add(items[i].Replace("\t", ""));
                 }
                 else if (items[i].Contains("Available formats:"))
                 {
                     here = true;
                 }
             }
             if (here == false)
             {
                 throw new Exception("Could not query available qualities(video not found).");
             }
         }
         toolStripStatusLabel1.Text = "";
         backgroundWorker2.ReportProgress(100);
     }
     catch (Exception ex)
     {
         toolStripStatusLabel1.Text = ex.Message;
         backgroundWorker2.ReportProgress(0);
     }
 }
コード例 #32
0
ファイル: SshCommand.cs プロジェクト: waffle-iron/nequeo
 /// <summary>
 /// Initializes a new instance of the <see cref="SshCommand"/> class.
 /// </summary>
 /// <param name="sshClient">The SSH client.</param>
 /// <param name="commandText">The command text.</param>
 /// <exception cref="ArgumentNullException">Either <paramref name="commandText"/> is null.</exception>
 internal SshCommand(Renci.SshNet.SshClient sshClient, string commandText)
 {
     _sshCommand = sshClient.CreateCommand(commandText);
 }
コード例 #33
-2
ファイル: Program.cs プロジェクト: DanielHang/Training
    static void Main(string[] args)
    {
        // Setup Credentials and Server Information
        ConnectionInfo ConnNfo = new ConnectionInfo("dan.hangone.co.za", 224, "Dan",
            new AuthenticationMethod[]{

                // Pasword based Authentication
                new PasswordAuthenticationMethod("Dan","letmein5")/*,

                // Key Based Authentication (using keys in OpenSSH Format)
                new PrivateKeyAuthenticationMethod("username",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 sftp = new SftpClient(ConnNfo))
        {
            string uploadfn = "Renci.SshNet.dll";

            sftp.Connect();
            sftp.ChangeDirectory("/tmp/uploadtest");
            using (var uplfileStream = System.IO.File.OpenRead(uploadfn))
            {
                sftp.UploadFile(uplfileStream, uploadfn, true);
            }
            sftp.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("/log print").Execute());
            Console.WriteLine(sshclient.CreateCommand("/int print").Execute());
            Console.WriteLine(sshclient.CreateCommand("/ppp secret print").Execute());
            sshclient.Disconnect();
        }
        Console.ReadKey();
    }