Java SshClient.openSessionChannel方法代码示例

import com.sshtools.j2ssh.SshClient; //导入方法依赖的package包/类
public void connect() throws IOException {
    lia.gsi.ssh.GSIAuthenticationClient gsiAuth = null;
    try {
        gsiAuth = new lia.gsi.ssh.GSIAuthenticationClient();
        gsiAuth.setUsername(username);
    } catch (GSSException e) {
        throw new IOException("Cannot load grid credentials.");
    }
    conn = new SshClient();
    SshToolsConnectionProfile properties = new SshToolsConnectionProfile();
    // TODO: add new "port" parameter
    properties.setPort(port);
    properties.setForwardingAutoStartMode(false);
    properties.setHost(hostname);
    properties.setUsername(username);
    conn.setUseDefaultForwarding(false);
    conn.connect(properties);
    try {
        // Authenticate the user
        int result = conn.authenticate(gsiAuth, hostname);
        if (result != AuthenticationProtocolState.COMPLETE) {
            throw new IOException("GSI authentication failed");
        }
        // Open a session channel
        sess = conn.openSessionChannel();
        sess.requestPseudoTerminal("javash", 0, 0, 0, 0, "");
    } catch (Throwable t) {
        throw new IOException(t.getMessage());
    }
}
 

import com.sshtools.j2ssh.SshClient; //导入方法依赖的package包/类
public static String executeCommand(String command) throws Exception {
	SessionChannelClient session = null;
	String res = "";
	try {
		SshClient ssh = connectSsh();
		// String command = getBundle().getString("ssh.cmd");

		session = ssh.openSessionChannel();
		OutputStream out = new java.io.ByteArrayOutputStream();

		session = ssh.openSessionChannel();
		IOStreamConnector output = new IOStreamConnector();
		output.connect(session.getInputStream(), out);

		if (session.executeCommand(command)) {
			session.getState().waitForState(ChannelState.CHANNEL_CLOSED, 15000);
			res = out.toString();
		} else {
			res = "Unable to execute command " + command;
		}
	} finally {
		try {
			session.close();
		} catch (Exception e) {
		}
	}
	return res;
}
 

import com.sshtools.j2ssh.SshClient; //导入方法依赖的package包/类
/**
 * Execute commands.
 *
 * @param host the host name of the server
 * @param port the port number the user want to use for connection
 * @param username the username required for authentication
 * @param password the password required for authentication
 * @param cmds the commands you want to execute remotely
 * @return the string with the parameters you entered 
 * @throws InterruptedException 
 * @throws IOException, InterruptedException
 */
public static String executeCommands(String host, int port,String username,String password, String[] cmds) throws IOException, InterruptedException {
	String commandOutput = "";
	SshClient ssh = connect(host, port,username, password);
	SessionChannelClient sessionChannel = ssh.openSessionChannel();

	// make a script out of all the commands
	StringBuilder cmdToExecute = new StringBuilder();
	for (String cmd : cmds) {
		cmdToExecute.append(cmd).append(";");
	}
	// execute the whole thing
	if (sessionChannel.executeCommand(cmdToExecute.toString())) {
		/**
		 * Reading from the session InputStream
		 */
		InputStream in = sessionChannel.getInputStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(in)); // read to buffer from the stream
	    StringBuffer buffer = new StringBuffer();
        String line;
		   while (((line = br.readLine()) !=  null)){ // read from the buffer of the stream the line
                  buffer.append(line); // append the result line to the String buffer.
                  buffer.append("\n");
		   }
		   commandOutput = buffer.toString(); 
		sessionChannel.getState().waitForState(ChannelState.CHANNEL_CLOSED);
		br.close();
		ssh.disconnect();
		return commandOutput;

	} 
	else {
		SSH_LOG.error("The command did not execute");
		ssh.disconnect();
		return commandOutput;
	}
}
 

import com.sshtools.j2ssh.SshClient; //导入方法依赖的package包/类
/**
 * Get shell and execute command.
 * 
 * @param cmd
 * @return
 * @throws Exception
 */
public String executeSudoCommand(String command) throws Exception {

	String res = "";
	SessionChannelClient session = null;
	try {
		SshClient ssh = connectSsh();
		session = ssh.openSessionChannel();

		if (session.requestPseudoTerminal("isfw", 80, 24, 0, 0, "")) {
			if (session.startShell()) {
				session.getOutputStream().write((command + "\n").getBytes());

				InputStream in = session.getInputStream();
				byte buffer[] = new byte[255];
				int read;

				while ((read = in.read(buffer)) > 0) {

					res += new String(buffer, 0, read);
					System.out.println("res: " + res);

					if (res.contains("password")) {
						session.getOutputStream().write((getBundle().getString("ssh.pwd") + "\n").getBytes());
						res = command + "\n";
					}

					if (res.contains(command)) {
						if (res.endsWith("]$ ")) {
							break;
						}
						if (command.equalsIgnoreCase("status") && res.endsWith("]$ ")) {
							break;
						}
					}
				}

			} else {
				res = "Unable to start shell.";
			}
		} else {
			res = "Unable to request terminal.";
		}
	} finally {
		try {
			session.close();
		} catch (Exception e) {
		}
	}
	return res;
}
 

import com.sshtools.j2ssh.SshClient; //导入方法依赖的package包/类
/**
 * The main program for the PasswordConnect class
 *
 * @param args The command line arguments
 */
public static void main(String args[]) {
  try {
    // Setup a logfile
    /*Handler fh = new FileHandler("example.log");
    fh.setFormatter(new SimpleFormatter());
    Logger.getLogger("com.sshtools").setUseParentHandlers(false);
    Logger.getLogger("com.sshtools").addHandler(fh);
    Logger.getLogger("com.sshtools").setLevel(Level.ALL);*/
    // Configure J2SSH (This will attempt to install the bouncycastle provider
    // under jdk 1.3.1)
    ConfigurationLoader.initialize(false);
    System.out.print("Connect to host? ");
    System.out.print("Connect to host? ");
    String hostname = reader.readLine();
    // Make a client connection
    SshClient ssh = new SshClient();
    SshConnectionProperties properties = new SshConnectionProperties();
    properties.setHost(hostname);
    // Connect to the host
    ssh.connect(properties);
    // Create a password authentication instance
    KBIAuthenticationClient kbi = new KBIAuthenticationClient();
    // Get the users name
    System.out.print("Username? ");
    // Read the password
    String username = reader.readLine();
    kbi.setUsername(username);
    kbi.setKBIRequestHandler(new KBIRequestHandler() {
      public void showPrompts(String name, String instructions,
                              KBIPrompt[] prompts) {
        System.out.println(name);
        System.out.println(instructions);
        String response;
        if (prompts != null) {
          for (int i = 0; i < prompts.length; i++) {
            System.out.print(prompts[i].getPrompt() + ": ");
            try {
              response = reader.readLine();
              prompts[i].setResponse(response);
            }
            catch (IOException ex) {
              prompts[i].setResponse("");
              ex.printStackTrace();
            }
          }
        }
      }
    });
    // Try the authentication
    int result = ssh.authenticate(kbi);
    // Evaluate the result
    if (result == AuthenticationProtocolState.COMPLETE) {
      // The connection is authenticated we can now do some real work!
      SessionChannelClient session = ssh.openSessionChannel();
      if(!session.requestPseudoTerminal("vt100", 80, 24, 0, 0, ""))
        System.out.println("Failed to allocate a pseudo terminal");
      if(session.startShell()) {
        IOStreamConnector input =
            new IOStreamConnector(System.in, session.getOutputStream());
        IOStreamConnector output =
            new IOStreamConnector(session.getInputStream(), System.out);
        output.getState().waitForState(IOStreamConnectorState.CLOSED);
      }else
        System.out.println("Failed to start the users shell");
      ssh.disconnect();
    }
  }
  catch (Exception e) {
    e.printStackTrace();
  }
}
 

import com.sshtools.j2ssh.SshClient; //导入方法依赖的package包/类
/**
 * The main program for the PasswordConnect class
 *
 * @param args The command line arguments
 */
public static void main(String args[]) {
  try {
    // JDK > 1.4 ONLY
    /*Handler fh = new FileHandler("example.log");
    fh.setFormatter(new SimpleFormatter());
    Logger.getLogger("com.sshtools").setUseParentHandlers(false);
    Logger.getLogger("com.sshtools").addHandler(fh);
    Logger.getLogger("com.sshtools").setLevel(Level.ALL);*/
    // Configure J2SSH (This will attempt to install the bouncycastle provider
    // under jdk 1.3.1)
    ConfigurationLoader.initialize(false);
    BufferedReader reader =
        new BufferedReader(new InputStreamReader(System.in));
    System.out.print("Connect to host? ");
    String hostname = reader.readLine();
    // Make a client connection
    SshClient ssh = new SshClient();
    ssh.setSocketTimeout(30000);
    SshConnectionProperties properties = new SshConnectionProperties();
    properties.setHost(hostname);
    properties.setPrefPublicKey("ssh-dss");
    // Connect to the host
    ssh.connect(properties);
    // Create a password authentication instance
    PasswordAuthenticationClient pwd = new PasswordAuthenticationClient();
    // Get the users name
    System.out.print("Username? ");
    // Read the password
    String username = reader.readLine();
    pwd.setUsername(username);
    // Get the password
    System.out.print("Password? ");
    String password = reader.readLine();
    pwd.setPassword(password);
    // Try the authentication
    int result = ssh.authenticate(pwd);
    // Evaluate the result
    if (result == AuthenticationProtocolState.COMPLETE) {
      // The connection is authenticated we can now do some real work!
      SessionChannelClient session = ssh.openSessionChannel();
      if(!session.requestPseudoTerminal("vt100", 80, 24, 0, 0, ""))
        System.out.println("Failed to allocate a pseudo terminal");
      if (session.startShell()) {
        IOStreamConnector input =
            new IOStreamConnector();
        IOStreamConnector output =
            new IOStreamConnector();
        IOStreamConnector error =
            new IOStreamConnector();
        output.setCloseOutput(false);
        input.setCloseInput(false);
        error.setCloseOutput(false);
        input.connect(System.in, session.getOutputStream());
        output.connect(session.getInputStream(), System.out);
        error.connect(session.getStderrInputStream(), System.out);
        session.getState().waitForState(ChannelState.CHANNEL_CLOSED);
      }else
        System.out.println("Failed to start the users shell");
      ssh.disconnect();
    }
  }
  catch (Exception e) {
    e.printStackTrace();
  }
}