Package | Description |
---|---|
com.maverick.agent | |
com.maverick.agent.client | |
com.maverick.agent.exceptions | |
com.maverick.agent.openssh | |
com.maverick.pool | |
com.maverick.scp |
This package contains a Secure Copy (SCP) engine suitable for the
lightweight J2SSH Maverick API.
|
com.maverick.sftp |
The base implementation of the SFTP protocol enabling SFTP to be
operated over both SSH1 and SSH2 connections.
|
com.maverick.ssh |
This package contains a set of general interface contracts for SSH communication that
provide the core set of functionality available in both the SSH1 and SSH2 protocol specifications.
|
com.maverick.ssh.components |
This package contains an abstract cryptographic provider for the SSH protocol.
|
com.maverick.ssh.components.jce |
This package contains a set of algoritm implementations that enable the Maverick API
to use a Java Cryptography Extension provider.
|
com.maverick.ssh.components.jce.client | |
com.maverick.ssh.message | |
com.maverick.ssh1 |
This package contains an SSH1 implementation of the
com.maverick.ssh interfaces.
|
com.maverick.ssh2 |
This package contains an SSH2 implementation of the
com.maverick.ssh interfaces.
|
com.sshtools.net |
This package contains a set of network utilities for the J2SSH Maverick API.
|
com.sshtools.publickey |
This package contains utility classes for loading/storing public/private keys
and is based on the SSHTools key format architecture.
|
com.sshtools.scp |
This package contains the SSHTools SCP implementation converted to use the
J2SSH Maverick API's SCP engine.
|
com.sshtools.sftp |
This package contains the SSHTools SFTP client converted for use with the J2SSH
Maverick API.
|
Modifier and Type | Method and Description |
---|---|
byte[] |
KeyStore.performHashAndSign(SshPublicKey pubkey,
List<ForwardingNotice> forwardingNodes,
byte[] data)
Hash and sign some data using a key stored in this keystore.
|
byte[] |
InMemoryKeyStore.performHashAndSign(SshPublicKey pubkey,
List<ForwardingNotice> forwardingNodes,
byte[] data) |
Modifier and Type | Method and Description |
---|---|
void |
Ssh2AgentAuthentication.authenticate(AuthenticationProtocol authentication,
String servicename) |
Ssh2Channel |
AgentForwardingChannelFactory.createChannel(String channeltype,
byte[] requestdata) |
byte[] |
SshAgentClient.sign(SshPublicKey key,
byte[] data) |
Modifier and Type | Class and Description |
---|---|
class |
InvalidMessageException |
Modifier and Type | Method and Description |
---|---|
protected SshKeyPair |
SshAgentAddKey.decodeKey(ByteArrayReader bar) |
protected void |
SshAgentAddKey.encodeKey(ByteArrayWriter baw) |
Modifier and Type | Method and Description |
---|---|
void |
SshClientFactory.authenticateClient(SshClient client)
Authenticate the client.
|
void |
SshClientAdapter.authenticateClient(SshClient client) |
SshClient |
SshClientPool.checkout(String host,
int port,
String username)
Check out an available client.
|
SshClient |
SshClientPool.checkout(String host,
int port,
String username,
SshClientFactory factory)
Check out an available client.
|
void |
SshClientFactory.configureConnector(SshConnector con)
Configure the connector.
|
void |
SshClientAdapter.configureConnector(SshConnector con) |
void |
SshTransferQueue.postGet(String host,
int port,
String username,
String filename,
SshTransferListener listener) |
void |
SshTransferQueue.postPut(String host,
int port,
String username,
String filename,
SshTransferListener listener) |
Modifier and Type | Method and Description |
---|---|
void |
ScpClientIO.ScpEngineIO.close()
Close the SCP engine and underlying session.
|
InputStream |
ScpClientIO.get(String remoteFile)
Gets a remote file as a
java.io.InputStream . |
InputStream |
ScpClientIO.get(String remoteFile,
FileTransferProgress progress)
Gets a remote file as a
java.io.InputStream . |
void |
ScpClientIO.put(InputStream in,
long length,
String localFile,
String remoteFile)
Uploads a
java.io.InputStream to a remote server as a file. |
void |
ScpClientIO.put(InputStream in,
long length,
String localFile,
String remoteFile,
boolean remoteIsDir,
FileTransferProgress progress) |
void |
ScpClientIO.put(InputStream in,
long length,
String localFile,
String remoteFile,
FileTransferProgress progress)
Uploads a
java.io.InputStream to a remote server as a file. |
Constructor and Description |
---|
ScpEngineIO(String cmd,
SshSession session)
Contruct the channel with the specified scp command.
|
Modifier and Type | Method and Description |
---|---|
boolean |
SftpFile.canRead()
Determine whether the user has read access to the file.
|
boolean |
SftpFile.canWrite()
Determine whether the user has write access to the file.
|
void |
SftpSubsystemChannel.changePermissions(SftpFile file,
int permissions)
Change the permissions of a file.
|
void |
SftpSubsystemChannel.changePermissions(String filename,
int permissions)
Change the permissions of a file.
|
void |
SftpSubsystemChannel.changePermissions(String filename,
String permissions)
Change the permissions of a file.
|
void |
SftpFile.close()
Close the file.
|
void |
SftpSubsystemChannel.closeFile(SftpFile file)
Close a file or directory.
|
void |
SftpSubsystemChannel.createLink(String targetpath,
String linkpath,
boolean symbolic)
Create a symbolic link.
|
void |
SftpSubsystemChannel.createSymbolicLink(String targetpath,
String linkpath)
Create a symbolic link.
|
void |
SftpFile.delete()
Delete this file/directory from the remote server.
|
String |
SftpSubsystemChannel.getAbsolutePath(SftpFile file)
Get the absolute path of a file.
|
String |
SftpSubsystemChannel.getAbsolutePath(String path)
Get the absolute path of a file.
|
SftpFileAttributes |
SftpFile.getAttributes()
Get the files attributes.
|
SftpFileAttributes |
SftpSubsystemChannel.getAttributes(SftpFile file)
Get the attributes of a file.
|
SftpFileAttributes |
SftpSubsystemChannel.getAttributes(String path)
Get the attributes of a file.
|
protected SftpFileAttributes |
SftpSubsystemChannel.getAttributes(String path,
int messageId,
String messageName) |
String |
SftpSubsystemChannel.getDefaultDirectory()
Gets the users default directory.
|
SftpMessage |
SftpSubsystemChannel.getExtensionResponse(UnsignedInteger32 requestId) |
SftpFile |
SftpSubsystemChannel.getFile(String path)
Utility method to obtain an
SftpFile instance for a given path. |
byte[] |
SftpSubsystemChannel.getHandleResponse(SftpMessage bar,
UnsignedInteger32 requestId) |
byte[] |
SftpSubsystemChannel.getHandleResponse(UnsignedInteger32 requestId) |
SftpFileAttributes |
SftpSubsystemChannel.getLinkAttributes(String path)
Get the attributes of a file.
|
void |
SftpSubsystemChannel.getOKRequestStatus(UnsignedInteger32 requestId)
Verify that an OK status has been returned for a request id.
|
SftpFile |
SftpFile.getParent()
Get the parent of the current file.
|
SftpMessage |
SftpSubsystemChannel.getResponse(UnsignedInteger32 requestId) |
SftpFile |
SftpSubsystemChannel.getSingleFileResponse(SftpMessage bar,
String messageName)
Get a single SftpFile object from a message returning SSH_FXP_NAME result.
|
String |
SftpSubsystemChannel.getSymbolicLinkTarget(String linkpath)
Get the target path of a symbolic link.
|
void |
SftpSubsystemChannel.initialize()
Initializes the sftp subsystem and negotiates a version with the server.
|
boolean |
SftpFile.isBlock()
Determine whether the file is pointing to a block special file.
|
boolean |
SftpFile.isCharacter()
Determine whether the file is pointing to a character mode device.
|
boolean |
SftpFile.isDirectory()
Determine whether the file object is pointing to a directory.
|
boolean |
SftpFile.isFifo()
Determine whether the file is pointing to a pipe.
|
boolean |
SftpFile.isFile()
Determine whether the file object is pointing to a file.
|
boolean |
SftpFile.isLink()
Determine whether the file object is a symbolic link.
|
boolean |
SftpFile.isSocket()
Determine whether the file is pointing to a socket.
|
int |
SftpSubsystemChannel.listChildren(SftpFile file,
Vector<SftpFile> children)
List the children of a directory.
|
int |
SftpSubsystemChannel.listChildren(SftpFile file,
Vector<SftpFile> children,
boolean disableAttributeCheck) |
void |
SftpSubsystemChannel.lockFile(byte[] handle,
long offset,
long length,
int lockFlags) |
void |
SftpSubsystemChannel.makeDirectory(String path)
Make a directory.
|
void |
SftpSubsystemChannel.makeDirectory(String path,
SftpFileAttributes attrs)
Make a directory.
|
SftpFile |
SftpSubsystemChannel.openDirectory(String path)
Open a directory.
|
SftpFile |
SftpSubsystemChannel.openDirectory(String path,
boolean disableAttributeCheck)
Open a directory.
|
SftpFile |
SftpSubsystemChannel.openFile(String absolutePath,
int flags)
Open a file.
|
SftpFile |
SftpSubsystemChannel.openFile(String absolutePath,
int flags,
SftpFileAttributes attrs)
Open a file.
|
SftpFile |
SftpSubsystemChannel.openFileVersion5(String absolutePath,
int flags,
int accessFlags,
SftpFileAttributes attrs) |
void |
SftpSubsystemChannel.performOptimizedRead(byte[] handle,
long length,
int blocksize,
OutputStream out,
int outstandingRequests,
FileTransferProgress progress)
Performs an optimized read of a file through use of asynchronous
messages.
|
void |
SftpSubsystemChannel.performOptimizedRead(byte[] handle,
long length,
int blocksize,
OutputStream out,
int outstandingRequests,
FileTransferProgress progress,
long position)
Performs an optimized read of a file through use of asynchronous
messages.
|
void |
SftpSubsystemChannel.performOptimizedWrite(byte[] handle,
int blocksize,
int outstandingRequests,
InputStream in,
int buffersize,
FileTransferProgress progress)
Performs an optimized write of a file through asynchronous messaging and
through buffering the local file into memory.
|
void |
SftpSubsystemChannel.performOptimizedWrite(byte[] handle,
int blocksize,
int outstandingRequests,
InputStream in,
int buffersize,
FileTransferProgress progress,
long position)
Performs an optimized write of a file through asynchronous messaging and
through buffering the local file into memory.
|
void |
SftpSubsystemChannel.performSynchronousRead(byte[] handle,
int blocksize,
OutputStream out,
FileTransferProgress progress,
long position)
Perform a synchronous read of a file from the remote file system.
|
UnsignedInteger32 |
SftpSubsystemChannel.postReadRequest(byte[] handle,
long offset,
int len)
Post a read request to the server and return the request id; this is used
to optimize file downloads.
|
UnsignedInteger32 |
SftpSubsystemChannel.postWriteRequest(byte[] handle,
long position,
byte[] data,
int off,
int len)
Send a write request for an open file but do not wait for the response
from the server.
|
int |
SftpSubsystemChannel.readFile(byte[] handle,
UnsignedInteger64 offset,
byte[] output,
int off,
int len)
Read a block of data from an open file.
|
void |
SftpSubsystemChannel.recurseMakeDirectory(String path)
Recurse through a hierarchy of directories creating them as necessary.
|
void |
SftpSubsystemChannel.removeDirectory(String path)
Remove an empty directory.
|
void |
SftpSubsystemChannel.removeFile(String filename)
Remove a file.
|
void |
SftpSubsystemChannel.renameFile(String oldpath,
String newpath)
Rename an existing file.
|
void |
SftpSubsystemChannel.renameFile(String oldpath,
String newpath,
int flags) |
UnsignedInteger32 |
SftpSubsystemChannel.sendExtensionMessage(String request,
byte[] requestData)
Send an extension message and return the response.
|
void |
SftpSubsystemChannel.setAttributes(SftpFile file,
SftpFileAttributes attrs)
Sets the attributes of a file.
|
void |
SftpSubsystemChannel.setAttributes(String path,
SftpFileAttributes attrs)
Sets the attributes of a file.
|
void |
SftpSubsystemChannel.setCharsetEncoding(String charset)
Allows the default character encoding to be overriden for filename
strings.
|
void |
SftpSubsystemChannel.unlockFile(byte[] handle,
long offset,
long length) |
void |
SftpSubsystemChannel.writeFile(byte[] handle,
UnsignedInteger64 offset,
byte[] data,
int off,
int len)
Write a block of data to an open file.
|
Constructor and Description |
---|
SftpFileInputStream(SftpFile file) |
SftpFileInputStream(SftpFile file,
long position)
Creates a new SftpFileInputStream object.
|
SftpFileOutputStream(SftpFile file)
Creates a new SftpFileOutputStream object.
|
SftpSubsystemChannel(SshSession session) |
SftpSubsystemChannel(SshSession session,
int maximumVersion) |
SftpSubsystemChannel(SshSession session,
int maximumVersion,
int timeout) |
Modifier and Type | Method and Description |
---|---|
SshException |
SshIOException.getRealException()
Get the real exception
|
Modifier and Type | Method and Description |
---|---|
int |
SshClient.authenticate(SshAuthentication auth)
Authenticate the user.
|
boolean |
SshClient.cancelRemoteForwarding(String bindAddress,
int bindPort)
Cancel a forwarding request.
|
void |
SshSession.changeTerminalDimensions(int cols,
int rows,
int width,
int height)
Change the dimensions of the terminal window.
|
void |
Shell.close() |
void |
SecurityPolicy.configure(String... matches) |
void |
DefaultSecurityPolicy.configure(String... matches) |
void |
AdaptiveSecurityPolicy.configure(String... matches) |
void |
SshClient.connect(SshTransport transport,
SshContext context,
SshClientConnector connector,
String username,
String localIdentification,
String remoteIdentification,
boolean buffered)
Connect to an SSH server.
|
SshClient |
SshConnector.connect(SshTransport transport,
String username) |
SshClient |
SshClientConnector.connect(SshTransport transport,
String username)
Create a new connection to an SSH server over the specified transport.
|
SshClient |
SshConnector.connect(SshTransport transport,
String username,
boolean buffered) |
SshClient |
SshClientConnector.connect(SshTransport transport,
String username,
boolean buffered)
See
SshClientConnector.connect(SshTransport, String) for full details. |
SshClient |
SshConnector.connect(SshTransport transport,
String username,
boolean buffered,
SshContext context) |
SshClient |
SshClientConnector.connect(SshTransport transport,
String username,
boolean buffered,
SshContext context)
See
SshClientConnector.connect(SshTransport, String) for full details. |
SshClient |
SshConnector.connect(SshTransport transport,
String username,
SshContext context) |
SshClient |
SshClientConnector.connect(SshTransport transport,
String username,
SshContext context)
See
SshClientConnector.connect(SshTransport, String) for full details. |
SshTransport |
ForwardingRequestListener.createConnection(String hostToConnect,
int portToConnect)
Create a connection to the specified host.
|
static SshConnector |
SshConnector.createInstance()
Deprecated.
Use alternative createInstance method that specifies a minimum SecurityLevel for your application and
|
static SshConnector |
SshConnector.createInstance(ExecutorService executorService)
Deprecated.
Use alternative createInstance method that specifies a minimum SecurityLevel for your application
|
static SshConnector |
SshConnector.createInstance(ExecutorService executor,
SecurityLevel securityLevel,
boolean managedSecurity)
Returns an instance of the
SshConnector . |
static SshConnector |
SshConnector.createInstance(ExecutorService executor,
SecurityPolicy securityPolicy) |
static SshConnector |
SshConnector.createInstance(SecurityLevel securityLevel,
boolean managedSecurity) |
static SshConnector |
SshConnector.createInstance(SecurityPolicy securityPolicy) |
static SshConnector |
SshConnector.createManagedInstance(SecurityLevel securityLevel) |
static String |
AdaptiveConfiguration.csv(ComponentFactory<?> algs,
SecurityLevel level) |
int |
SshConnector.determineVersion(SshTransport transport)
Determine the version of the server connected to the SshTransport.
|
SshClient |
SshClient.duplicate()
Create an identical version of an SshClient using cached authentication
information and the SshTransport duplicate method.
|
void |
SshContext.enableFIPSMode()
Deprecated.
This method is out-of-date. Use JCEProvider.initializeDefaultProvider("BCFIPS") passing a FIPS approved JCE provider
in approved mode to restrict algorithms to only those supported by the approved FIPS environment.
|
void |
SshConnector.enableFIPSMode()
Deprecated.
This method is out-of-date. Use JCEProvider.initializeDefaultProvider("BCFIPS") passing a FIPS approved JCE provider
in approved mode to restrict algorithms to only those supported by the approved FIPS environment.
|
boolean |
SshSession.executeCommand(String cmd)
Execute a command.
|
ShellProcess |
Shell.executeCommand(String origCmd) |
ShellProcess |
Shell.executeCommand(String origCmd,
boolean consume) |
ShellProcess |
Shell.executeCommand(String origCmd,
boolean matchPromptMarker,
boolean consume) |
ShellProcess |
Shell.executeCommand(String origCmd,
boolean matchPromptMarker,
boolean consume,
String charset) |
ShellProcess |
Shell.executeCommand(String origCmd,
boolean consume,
String charset) |
boolean |
SshSession.executeCommand(String cmd,
String charset)
Execute a command.
|
ShellProcess |
Shell.executeCommand(String origCmd,
String charset) |
void |
Shell.exit() |
void |
Client.exit() |
boolean |
ShellController.expect(String pattern)
Consume the output of the command until the pattern matches.
|
boolean |
ShellController.expect(String pattern,
boolean consumeRemainingLine)
Consume the output of the command until the pattern matches.
|
boolean |
ShellController.expect(String pattern,
boolean consumeRemainingLine,
long timeout)
Consume the output of the command until the pattern matches.
|
boolean |
ShellController.expect(String pattern,
boolean consumeRemainingLine,
long timeout,
long maxLines)
Consume the output of the command until the pattern matches.
|
boolean |
ShellController.expect(String pattern,
long timeout)
Consume the output of the command until the pattern matches.
|
boolean |
ShellController.expectNextLine(String pattern)
Perform expect on the next line of output only
|
boolean |
ShellController.expectNextLine(String pattern,
boolean consumeRemainingLine)
Perform expect on the next line of output only
|
boolean |
ShellController.expectNextLine(String pattern,
boolean consumeRemainingLine,
long timeout)
Perform expect on the next line of output only
|
static String |
SshConnector.getAvailableCiphers() |
static String |
SshConnector.getAvailableCiphers(SecurityLevel securityLevel) |
static String |
SshConnector.getAvailableCompressions() |
static String |
SshConnector.getAvailableKeyExchanges() |
static String |
SshConnector.getAvailableKeyExchanges(SecurityLevel securityLevel) |
static String |
SshConnector.getAvailableMacs() |
static String |
SshConnector.getAvailableMacs(SecurityLevel securityLevel) |
static String |
SshConnector.getAvailablePublicKeys() |
static String |
SshConnector.getAvailablePublicKeys(SecurityLevel securityLevel) |
Ssh2Context |
SshConnector.getContext()
Get the SSH2 context
|
SshContext |
SshConnector.getContext(int version)
Deprecated.
Future version will only support SSH2. Use getContext without parameters.
|
static String |
SshConnector.getDefaultConfiguration(SecurityLevel securityLevel) |
static String |
SshKeyFingerprint.getFingerprint(byte[] encoded)
Generate an SSH key fingerprint as defined in
draft-ietf-secsh-fingerprint-00.txt.
|
static String |
SshKeyFingerprint.getFingerprint(byte[] encoded,
String algorithm)
Generate an SSH key fingerprint with a specific algorithm.
|
static String |
SshKeyFingerprint.getFingerprint(byte[] encoded,
String algorithm,
SshKeyFingerprint.Encoding encoding) |
static String |
SshKeyFingerprint.getFingerprint(SshPublicKey key,
String algorithm) |
static String |
SshKeyFingerprint.getFingerprint(SshPublicKey key,
String algorithm,
SshKeyFingerprint.Encoding encoding) |
static SshPublicKey |
SshKeyUtils.getHostKey(String hostname,
int port) |
static SshPublicKey |
SshCompatibilityUtils.getHostKey(String hostname,
int port) |
static SshPublicKey |
SshKeyUtils.getHostKey(String hostname,
int port,
String algorithm) |
static SshPublicKey |
SshCompatibilityUtils.getHostKey(String hostname,
int port,
String algorithm) |
static SshClient |
SshCompatibilityUtils.getRemoteClient(String hostname,
int port,
String username,
String password,
boolean tcpNoDelay) |
static SshClient |
SshCompatibilityUtils.getRemoteClient(String hostname,
int port,
String username,
String password,
boolean tcpNoDelay,
String cipher) |
static ConfigurationCollector |
SshDiagnostics.getRemoteConfiguration(String hostname,
int port) |
static ConfigurationCollector |
SshCompatibilityUtils.getRemoteConfiguration(String hostname,
int port) |
static String |
AdaptiveConfiguration.getSecurityLevel(SecurityLevel securityLevel,
String configurationDirective,
ComponentFactory<?> factory) |
static String[] |
SshKeyUtils.getSupportedHostKeyAlgorithms(String hostname,
int port) |
static String[] |
SshCompatibilityUtils.getSupportedHostKeyAlgorithms(String hostname,
int port) |
static Set<SshPublicKey> |
SshKeyUtils.getSupportedHostKeys(String hostname,
int port) |
static Set<SshPublicKey> |
SshCompatibilityUtils.getSupportedHostKeys(String hostname,
int port) |
byte[] |
SshContext.getX11AuthenticationCookie()
Get a fake random cookie for X11 authentication
|
byte[] |
SshContext.getX11RealCookie()
Get the real X11 authentication cookie, if not cookie has been set the
fake cookie will be returned.
|
boolean |
HostKeyUpdater.isKnownHost(String host,
SshPublicKey key) |
static void |
SshTests.main(String[] args) |
static void |
SshReporter.main(String[] args) |
static void |
SshDiagnostics.main(String[] args) |
byte[] |
SubsystemChannel.nextMessage()
Read a subsystem message from the channel inputstream.
|
SshTunnel |
SshClient.openForwardingChannel(String hostname,
int port,
String listeningAddress,
int listeningPort,
String originatingHost,
int originatingPort,
SshTransport transport,
ChannelEventListener listener)
Open a TCPIP forwarding channel to the remote computer.
|
SshClient |
SshClient.openRemoteClient(String hostname,
int port,
String username)
Open up an SSH client from the remote machine to another remote server.
|
SshClient |
SshClient.openRemoteClient(String hostname,
int port,
String username,
SshClientConnector con)
Open up an SSH client from the remote machine to another remote server.
|
SshSession |
SshClient.openSessionChannel()
Open a session on the remote computer.
|
SshSession |
SshClient.openSessionChannel(ChannelEventListener listener)
Open a session on the remote computer.
|
SshSession |
SshClient.openSessionChannel(ChannelEventListener listener,
long timeout)
Open a session on the remote computer.
|
SshSession |
SshClient.openSessionChannel(int windowspace,
int packetsize,
ChannelEventListener listener) |
SshSession |
SshClient.openSessionChannel(int windowspace,
int packetsize,
ChannelEventListener listener,
long timeout) |
SshSession |
SshClient.openSessionChannel(long timeout)
Open a session on the remote computer.
|
static void |
SshConnector.printDefaultConfiguration() |
String |
ShellReader.readLine()
Read a line of output from the process.
|
String |
ShellController.readLine() |
String |
ShellReader.readLine(long timeout)
Read a line of output from the process.
|
String |
ShellController.readLine(long timeout) |
boolean |
SshSession.requestPseudoTerminal(String term,
int cols,
int rows,
int width,
int height)
The remote process may require a pseudo terminal.
|
boolean |
SshSession.requestPseudoTerminal(String term,
int cols,
int rows,
int width,
int height,
byte[] modes)
The remote process may require a pseudo terminal.
|
boolean |
SshSession.requestPseudoTerminal(String term,
int cols,
int rows,
int width,
int height,
PseudoTerminalModes terminalModes)
The remote process may require a pseudo terminal.
|
int |
SshClient.requestRemoteForwarding(String bindAddress,
int bindPort,
String hostToConnect,
int portToConnect,
ForwardingRequestListener listener)
Requests that the remote computer accepts socket connections and forward
them to the local computer.
|
static void |
AdaptiveConfiguration.resetConfiguration() |
static void |
SshTests.runCorruptTransport(String hostname,
int port,
String username,
String password,
String tag) |
protected void |
SubsystemChannel.sendMessage(Packet msg)
Write a subsystem message to the channel outputstream.
|
void |
SshConnector.setSupportedVersions(int supported)
Deprecated.
Future version will only support SSH2
|
void |
PseudoTerminalModes.setTerminalMode(int mode,
boolean value)
Set a boolean value mode
|
void |
PseudoTerminalModes.setTerminalMode(int mode,
int value)
Set an integer value mode
|
boolean |
SshSession.startShell()
Start the users default shell.
|
Shell |
Shell.su(String cmd) |
Shell |
Shell.su(String cmd,
String password) |
Shell |
Shell.su(String cmd,
String password,
String promptExpression) |
Shell |
Shell.su(String cmd,
String password,
String promptExpression,
ShellMatcher matcher) |
ShellProcess |
Shell.sudo(String cmd,
String password) |
ShellProcess |
Shell.sudo(String cmd,
String password,
String promptExpression) |
ShellProcess |
Shell.sudo(String cmd,
String password,
String promptExpression,
ShellMatcher matcher) |
void |
HostKeyUpdater.updateHostKey(String host,
SshPublicKey key) |
boolean |
HostKeyVerification.verifyHost(String host,
SshPublicKey pk)
Verify that the public key is acceptable for the host.
|
Constructor and Description |
---|
SshIOException(SshException realEx)
Construct the exception with the real exception.
|
Constructor and Description |
---|
AdaptiveSecurityPolicy() |
Shell(SshClient ssh) |
Shell(SshClient ssh,
ShellStartupTrigger trigger) |
Shell(SshClient ssh,
ShellStartupTrigger trigger,
long startupTimeout) |
Shell(SshClient ssh,
ShellStartupTrigger trigger,
long startupTimeout,
String termtype) |
Shell(SshClient ssh,
ShellStartupTrigger trigger,
long startupTimeout,
String termtype,
int cols,
int rows) |
SubsystemChannel(SshChannel channel,
int timeout)
Create a new subsystem channel.
|
Modifier and Type | Method and Description |
---|---|
String |
ComponentFactory.changePositionofAlgorithm(String name,
int position) |
void |
ComponentFactory.configureSecurityLevel(SecurityLevel securityLevel) |
void |
ComponentFactory.configureSecurityLevel(SecurityLevel securityLevel,
boolean locked) |
abstract SshDsaPrivateKey |
ComponentManager.createDsaPrivateKey(BigInteger p,
BigInteger q,
BigInteger g,
BigInteger x,
BigInteger y)
Create an instance of a DSA private key.
|
abstract SshDsaPublicKey |
ComponentManager.createDsaPublicKey(BigInteger p,
BigInteger q,
BigInteger g,
BigInteger y)
Create an instance of a DSA public key.
|
String |
ComponentFactory.createNewOrdering(int[] ordering) |
abstract SshRsaPrivateCrtKey |
ComponentManager.createRsaPrivateCrtKey(BigInteger modulus,
BigInteger publicExponent,
BigInteger privateExponent,
BigInteger primeP,
BigInteger primeQ,
BigInteger crtCoefficient)
Create an instance of an RSA co-effecient private key.
|
abstract SshRsaPrivateCrtKey |
ComponentManager.createRsaPrivateCrtKey(BigInteger modulus,
BigInteger publicExponent,
BigInteger privateExponent,
BigInteger primeP,
BigInteger primeQ,
BigInteger primeExponentP,
BigInteger primeExponentQ,
BigInteger crtCoefficient)
Create an instance of an RSA co-efficent private key.
|
abstract SshRsaPrivateKey |
ComponentManager.createRsaPrivateKey(BigInteger modulus,
BigInteger privateExponent)
Create an instance of an RSA private key.
|
abstract SshRsaPublicKey |
ComponentManager.createRsaPublicKey(BigInteger modulus,
BigInteger publicExponent,
int version)
Create an instance of an RSA public key.
|
abstract SshRsaPublicKey |
ComponentManager.createSsh2RsaPublicKey()
Create an instance of an SSH2 RSA public key.
|
BigInteger |
SshRsaPrivateCrtKey.doPrivate(BigInteger input) |
BigInteger |
SshRsaPublicKey.doPublic(BigInteger input) |
abstract SshKeyPair |
ComponentManager.generateDsaKeyPair(int bits)
Generate a new DSA public/private key pair.
|
abstract SshKeyPair |
ComponentManager.generateEcdsaKeyPair(int bits)
Generate a new ECDSA key pair.
|
abstract SshKeyPair |
ComponentManager.generateEd25519KeyPair() |
abstract SshKeyPair |
ComponentManager.generateEd448KeyPair() |
abstract SshKeyPair |
ComponentManager.generateRsaKeyPair(int bits,
int version)
Generate an RSA public/private pair.
|
byte[] |
SshPublicKey.getEncoded()
Encode the public key into a blob of binary data, the encoded result will be
passed into init to recreate the key.
|
String |
SshPublicKey.getFingerprint()
Return an SSH fingerprint of the public key
|
Object |
ComponentFactory.getInstance(String name)
Get a new instance of a supported component.
|
abstract SshSecureRandomGenerator |
ComponentManager.getRND()
Get the secure random number generator.
|
protected void |
ComponentManager.init() |
void |
SshHmac.init(byte[] keydata) |
void |
NoneHmac.init(byte[] keydata) |
void |
SshPublicKey.init(byte[] blob,
int start,
int len)
Initialize the public key from a blob of binary data.
|
void |
SshSecureRandomGenerator.nextBytes(byte[] bytes,
int off,
int len) |
String |
ComponentFactory.order(String[] ordering) |
String |
ComponentFactory.selectStrongestComponent(String[] remoteAlgs) |
void |
ComponentManager.setMinimumSecurityLevel(SecurityLevel securityLevel) |
void |
ComponentManager.setMinimumSecurityLevel(SecurityLevel securityLevel,
boolean managedSecurity) |
void |
SshKeyExchange.test() |
boolean |
SshPublicKey.verifySignature(byte[] signature,
byte[] data)
Verify the signature.
|
Modifier and Type | Method and Description |
---|---|
SshDsaPrivateKey |
JCEComponentManager.createDsaPrivateKey(BigInteger p,
BigInteger q,
BigInteger g,
BigInteger x,
BigInteger y) |
SshDsaPublicKey |
JCEComponentManager.createDsaPublicKey(BigInteger p,
BigInteger q,
BigInteger g,
BigInteger y) |
SshRsaPrivateCrtKey |
JCEComponentManager.createRsaPrivateCrtKey(BigInteger modulus,
BigInteger publicExponent,
BigInteger privateExponent,
BigInteger primeP,
BigInteger primeQ,
BigInteger crtCoefficient) |
SshRsaPrivateCrtKey |
JCEComponentManager.createRsaPrivateCrtKey(BigInteger modulus,
BigInteger publicExponent,
BigInteger privateExponent,
BigInteger primeP,
BigInteger primeQ,
BigInteger primeExponentP,
BigInteger primeExponentQ,
BigInteger crtCoefficient) |
SshRsaPrivateKey |
JCEComponentManager.createRsaPrivateKey(BigInteger modulus,
BigInteger privateExponent) |
SshRsaPublicKey |
JCEComponentManager.createRsaPublicKey(BigInteger modulus,
BigInteger publicExponent,
int version) |
SshRsaPublicKey |
JCEComponentManager.createSsh2RsaPublicKey() |
protected void |
OpenSshCertificate.decodeCertificate(ByteArrayReader reader) |
protected void |
OpenSshRsaSha512Certificate.decodePublicKey(ByteArrayReader reader) |
protected void |
OpenSshRsaSha256Certificate.decodePublicKey(ByteArrayReader reader) |
protected void |
OpenSshRsaCertificate.decodePublicKey(ByteArrayReader reader) |
protected void |
OpenSshEd25519Certificate.decodePublicKey(ByteArrayReader reader) |
protected void |
OpenSshEcdsaCertificate.decodePublicKey(ByteArrayReader reader) |
protected void |
OpenSshDsaCertificate.decodePublicKey(ByteArrayReader reader) |
protected abstract void |
OpenSshCertificate.decodePublicKey(ByteArrayReader reader) |
BigInteger |
Ssh2RsaPrivateCrtKey.doPrivate(BigInteger input) |
BigInteger |
Ssh2RsaPublicKey.doPublic(BigInteger input) |
BigInteger |
OpenSshRsaSha512Certificate.doPublic(BigInteger input) |
BigInteger |
OpenSshRsaSha256Certificate.doPublic(BigInteger input) |
BigInteger |
OpenSshRsaCertificate.doPublic(BigInteger input) |
protected void |
OpenSshCertificate.encodeCertificate(ByteArrayWriter writer) |
SshKeyPair |
JCEComponentManager.generateDsaKeyPair(int bits) |
SshKeyPair |
JCEComponentManager.generateEcdsaKeyPair(int bits) |
SshKeyPair |
JCEComponentManager.generateEd25519KeyPair() |
SshKeyPair |
JCEComponentManager.generateEd448KeyPair() |
SshKeyPair |
JCEComponentManager.generateRsaKeyPair(int bits,
int version) |
byte[] |
SshX509RsaSha1PublicKey.getEncoded()
Encode the public key into a blob of binary data, the encoded result will
be passed into init to recreate the key.
|
byte[] |
SshX509RsaPublicKeyRfc6187.getEncoded() |
byte[] |
SshX509RsaPublicKey.getEncoded()
Encode the public key into a blob of binary data, the encoded result
will be passed into init to recreate the key.
|
byte[] |
SshX509Rsa2048Sha256Rfc6187.getEncoded() |
byte[] |
SshX509EcdsaSha2NistPublicKeyRfc6187.getEncoded() |
byte[] |
SshX509DsaPublicKeyRfc6187.getEncoded() |
byte[] |
SshX509DsaPublicKey.getEncoded()
Encode the public key into a blob of binary data, the encoded result
will be passed into init to recreate the key.
|
byte[] |
SshEd448PublicKeyJCE.getEncoded() |
byte[] |
SshEd25519PublicKeyJCE.getEncoded() |
byte[] |
Ssh2RsaPublicKey.getEncoded() |
byte[] |
Ssh2EcdsaSha2NistPublicKey.getEncoded() |
byte[] |
Ssh2DsaPublicKey.getEncoded()
Encode the public key into a blob of binary data, the encoded result will
be passed into init to recreate the key.
|
byte[] |
Ssh1RsaPublicKey.getEncoded()
Get the encoded format required by SSH1
|
byte[] |
OpenSshCertificate.getEncoded() |
String |
SshEd448PublicKeyJCE.getFingerprint() |
String |
SshEd25519PublicKeyJCE.getFingerprint() |
String |
Ssh2RsaPublicKey.getFingerprint() |
String |
Ssh2EcdsaSha2NistPublicKey.getFingerprint() |
String |
Ssh2DsaPublicKey.getFingerprint() |
String |
OpenSshCertificate.getFingerprint() |
SshSecureRandomGenerator |
JCEComponentManager.getRND() |
OpenSshCertificate |
OpenSshCertificate.init(byte[] blob) |
void |
HmacSha512ETM.init(byte[] keydata) |
void |
HmacSha512.init(byte[] keydata) |
void |
HmacSha256_at_ssh_dot_com.init(byte[] keydata) |
void |
HmacSha256ETM.init(byte[] keydata) |
void |
HmacSha256.init(byte[] keydata) |
void |
HmacSha1ETM.init(byte[] keydata) |
void |
HmacSha196.init(byte[] keydata) |
void |
HmacSha1.init(byte[] keydata) |
void |
HmacRipeMd160ETM.init(byte[] keydata) |
void |
HmacRipeMd160.init(byte[] keydata) |
void |
AbstractHmac.init(byte[] keydata) |
void |
SshX509RsaSha1PublicKey.init(byte[] blob,
int start,
int len)
Initialize the public key from a blob of binary data.
|
void |
SshX509RsaPublicKeyRfc6187.init(byte[] blob,
int start,
int len) |
void |
SshX509RsaPublicKey.init(byte[] blob,
int start,
int len)
Initialize the public key from a blob of binary data.
|
void |
SshX509Rsa2048Sha256Rfc6187.init(byte[] blob,
int start,
int len) |
void |
SshX509EcdsaSha2NistPublicKeyRfc6187.init(byte[] blob,
int start,
int len) |
void |
SshX509DsaPublicKeyRfc6187.init(byte[] blob,
int start,
int len) |
void |
SshX509DsaPublicKey.init(byte[] blob,
int start,
int len)
Initialize the public key from a blob of binary data.
|
void |
SshEd448PublicKeyJCE.init(byte[] blob,
int start,
int len) |
void |
SshEd25519PublicKeyJCE.init(byte[] blob,
int start,
int len) |
void |
Ssh2RsaPublicKey.init(byte[] blob,
int start,
int len) |
void |
Ssh2EcdsaSha2NistPublicKey.init(byte[] blob,
int start,
int len) |
void |
Ssh2DsaPublicKey.init(byte[] blob,
int start,
int len)
Initialize the public key from a blob of binary data.
|
void |
OpenSshCertificate.init(byte[] blob,
int start,
int len) |
void |
SecureRND.nextBytes(byte[] bytes,
int off,
int len) |
void |
OpenSshCertificate.sign(SshPublicKey publicKey,
UnsignedInteger64 serial,
int type,
String keyId,
List<String> validPrincipals,
UnsignedInteger64 validAfter,
UnsignedInteger64 validBefore,
List<CriticalOption> criticalOptions,
List<CertificateExtension> extensions,
SshKeyPair signingKey) |
void |
OpenSshCertificate.verify() |
boolean |
SshEd448PublicKeyJCE.verifySignature(byte[] signature,
byte[] data) |
boolean |
SshEd25519PublicKeyJCE.verifySignature(byte[] signature,
byte[] data) |
boolean |
Ssh2RsaPublicKey.verifySignature(byte[] signature,
byte[] data) |
boolean |
Ssh2EcdsaSha2NistPublicKey.verifySignature(byte[] signature,
byte[] data) |
boolean |
Ssh2DsaPublicKey.verifySignature(byte[] signature,
byte[] data)
Verify the signature.
|
boolean |
OpenSshRsaSha512Certificate.verifySignature(byte[] signature,
byte[] data) |
boolean |
OpenSshRsaSha256Certificate.verifySignature(byte[] signature,
byte[] data) |
boolean |
OpenSshRsaCertificate.verifySignature(byte[] signature,
byte[] data) |
boolean |
OpenSshEd25519Certificate.verifySignature(byte[] signature,
byte[] data)
Verify the signature.
|
boolean |
OpenSshEcdsaCertificate.verifySignature(byte[] signature,
byte[] data) |
boolean |
OpenSshDsaCertificate.verifySignature(byte[] signature,
byte[] data) |
Constructor and Description |
---|
Ssh2DsaPrivateKey(BigInteger p,
BigInteger q,
BigInteger g,
BigInteger x,
BigInteger y) |
Modifier and Type | Method and Description |
---|---|
protected void |
DiffieHellmanGroup18Sha512.afterSentParameterE() |
protected void |
DiffieHellmanGroup.afterSentParameterE() |
protected void |
Rsa2048Sha256.calculateExchangeHash()
Calculates the exchange hash as an SHA1 hash of the following data.
|
protected void |
Rsa1024Sha1.calculateExchangeHash()
Calculates the exchange hash as an SHA1 hash of the following data.
|
protected void |
DiffieHellmanGroup1Sha1.calculateExchangeHash()
Calculates the exchange hash as an SHA1 hash of the following data.
|
protected void |
DiffieHellmanGroup14Sha1.calculateExchangeHash()
Calculates the exchange hash as an SHA1 hash of the following data.
|
protected void |
DiffieHellmanGroup.calculateExchangeHash()
Calculates the exchange hash as an SHA1 hash of the following data.
|
protected void |
DiffieHellmanEcdh.calculateExchangeHash() |
protected void |
Curve25519SHA256.calculateExchangeHash() |
protected void |
DiffieHellmanGroupExchangeSha1.calculateExchangeHash(boolean disableBackwardsCompatibility,
int minimumSize,
int preferredKeySize,
int maximumSize)
Calculates the exchange hash as an SHA1 hash of the following data.
|
void |
Rsa2048Sha256.performClientExchange(String clientIdentification,
String serverIdentification,
byte[] clientKexInit,
byte[] serverKexInit) |
void |
Rsa1024Sha1.performClientExchange(String clientIdentification,
String serverIdentification,
byte[] clientKexInit,
byte[] serverKexInit) |
void |
DiffieHellmanGroupExchangeSha1.performClientExchange(String clientIdentification,
String serverIdentification,
byte[] clientKexInit,
byte[] serverKexInit)
The client requests a modulus from the server indicating the pre- ferred
size.
|
void |
DiffieHellmanGroup1Sha1.performClientExchange(String clientIdentification,
String serverIdentification,
byte[] clientKexInit,
byte[] serverKexInit) |
void |
DiffieHellmanGroup14Sha1.performClientExchange(String clientIdentification,
String serverIdentification,
byte[] clientKexInit,
byte[] serverKexInit) |
void |
DiffieHellmanGroup.performClientExchange(String clientIdentification,
String serverIdentification,
byte[] clientKexInit,
byte[] serverKexInit) |
void |
DiffieHellmanEcdh.performClientExchange(String clientId,
String serverId,
byte[] clientKexInit,
byte[] serverKexInit) |
void |
Curve25519SHA256.performClientExchange(String clientId,
String serverId,
byte[] clientKexInit,
byte[] serverKexInit) |
Modifier and Type | Method and Description |
---|---|
void |
SshMessageRouter.blockForMessage(long timeout) |
protected abstract SshMessage |
SshMessageRouter.createMessage(byte[] msg)
Called by the message routing framework to request the creation of an
SshMessage . |
protected SshMessageStore |
SshAbstractChannel.getMessageStore() |
byte[] |
SshMessageReader.nextMessage(long timeout) |
SshMessage |
SshMessageStore.nextMessage(MessageObserver observer,
long timeout) |
protected SshMessage |
SshMessageRouter.nextMessage(SshAbstractChannel channel,
MessageObserver observer,
long timeout) |
protected abstract boolean |
SshAbstractChannel.processChannelMessage(SshChannelMessage m) |
protected abstract boolean |
SshMessageRouter.processGlobalMessage(SshMessage msg)
Called by the message routing framework so that the routing implementation may process
a global message.
|
Constructor and Description |
---|
SshChannelMessage(byte[] msg) |
Modifier and Type | Method and Description |
---|---|
int |
Ssh1Client.authenticate(SshAuthentication auth) |
boolean |
Ssh1Client.cancelRemoteForwarding(String bindAddress,
int bindPort)
The bindAddress is ignored since the SSH1 protocol does not support
setting of the bind address.
|
void |
Ssh1Client.connect(SshTransport transport,
SshContext context,
SshClientConnector connector,
String username,
String localIdentification,
String remoteIdentification,
boolean buffered) |
SshCipher |
Ssh1Context.createCipher(int cipherType) |
SshClient |
Ssh1Client.duplicate() |
void |
Ssh1Context.enableFIPSMode()
Deprecated.
This method is out-of-date. Use JCEProvider.initializeDefaultProvider("BCFIPS") passing a FIPS approved JCE provider
in approved mode to restrict algorithms to only those supported by the approved FIPS environment.
|
int |
Ssh1Context.getCipherType(int supportedCiphers)
Get the cipher type for this configuration context.
|
byte[] |
Ssh1Context.getX11AuthenticationCookie() |
byte[] |
Ssh1Context.getX11RealCookie() |
SshTunnel |
Ssh1Client.openForwardingChannel(String hostname,
int port,
String listeningAddress,
int listeningPort,
String originatingHost,
int originatingPort,
SshTransport transport,
ChannelEventListener listener) |
SshClient |
Ssh1Client.openRemoteClient(String hostname,
int port,
String username) |
SshClient |
Ssh1Client.openRemoteClient(String hostname,
int port,
String username,
SshClientConnector con) |
SshSession |
Ssh1Client.openSessionChannel()
Opens the one and only session channel available on an SSH1 connection,
calling this method multiple times on the same client instance will
return the same session instance.
|
SshSession |
Ssh1Client.openSessionChannel(ChannelEventListener listener) |
SshSession |
Ssh1Client.openSessionChannel(ChannelEventListener listener,
long timeout) |
SshSession |
Ssh1Client.openSessionChannel(int windowspace,
int packetsize,
ChannelEventListener listener) |
SshSession |
Ssh1Client.openSessionChannel(int windowspace,
int packetsize,
ChannelEventListener listener,
long timeout) |
SshSession |
Ssh1Client.openSessionChannel(long timeout) |
int |
Ssh1Client.requestRemoteForwarding(String bindAddress,
int bindPort,
String hostToConnect,
int portToConnect,
ForwardingRequestListener listener)
The bindAddress is ignored since the SSH1 protocol does not support
setting of the bind address.
|
boolean |
Ssh1Client.requestXForwarding(String display,
ForwardingRequestListener listener) |
Modifier and Type | Method and Description |
---|---|
void |
Ssh2Client.addChannelFactory(ChannelFactory factory)
Installs a custom channel factory so that the client may respond to
channel open requests.
|
void |
Ssh2Client.addRequestHandler(GlobalRequestHandler handler)
Installs a global request handler so that the client may respond to
global requests.
|
int |
AuthenticationProtocol.authenticate(AuthenticationClient auth,
String servicename)
Authenticate using the mechanism provided.
|
void |
Ssh2PublicKeyAuthentication.authenticate(AuthenticationProtocol authentication,
String servicename) |
void |
Ssh2PasswordAuthentication.authenticate(AuthenticationProtocol authentication,
String servicename)
Implementation of the authentication method.
|
void |
Ssh2HostbasedAuthentication.authenticate(AuthenticationProtocol authentication,
String servicename) |
void |
KBIAuthentication.authenticate(AuthenticationProtocol authentication,
String servicename) |
void |
AuthenticationClient.authenticate(AuthenticationProtocol authentication,
String servicename)
Perform the authentication according to the specification.
|
int |
Ssh2Client.authenticate(SshAuthentication auth) |
boolean |
Ssh2Client.cancelRemoteForwarding(String bindAddress,
int bindPort) |
void |
Ssh2Session.changeTerminalDimensions(int cols,
int rows,
int width,
int height) |
protected void |
Ssh2Session.channelRequest(String requesttype,
boolean wantreply,
byte[] requestdata)
This overidden method handles the "exit-status", "exit-signal" and
"xon-xoff" channel requests.
|
protected void |
Ssh2Channel.channelRequest(String requesttype,
boolean wantreply,
byte[] requestdata)
Called when a channel request is received, by default this method sends a
failure message if the remote side requests a reply.
|
void |
Ssh2Context.configureSecurityLevel(SecurityLevel securityLevel) |
void |
Ssh2Client.connect(SshTransport io,
SshContext context,
SshClientConnector connector,
String username,
String localIdentification,
String remoteIdentification,
boolean buffered) |
Ssh2Channel |
ChannelFactory.createChannel(String channeltype,
byte[] requestdata)
Create an instance of an SSH channel.
|
void |
Ssh2Context.disableCompression() |
SshClient |
Ssh2Client.duplicate() |
void |
Ssh2Context.enableCompression() |
void |
Ssh2Context.enableFIPSMode()
Deprecated.
This method is out-of-date. Use JCEProvider.initializeDefaultProvider("BCFIPS") passing a FIPS approved JCE provider
in approved mode to restrict algorithms to only those supported by the approved FIPS environment.
|
boolean |
Ssh2Session.executeCommand(String cmd) |
boolean |
Ssh2Session.executeCommand(String cmd,
String charset) |
void |
Ssh2Client.forceKeyExchange()
The SSH transport protocol exchanges keys at the beginning of the
session; the specification recommends that these keys be re-exchanged
after each gigabyte of transmitted data or after each hour of connection
time, whichever comes sooner.
|
String[] |
Ssh2Client.getAuthenticationMethods(String username)
Get a list of authentication methods for the user.
|
String |
AuthenticationProtocol.getAuthenticationMethods(String username,
String servicename)
Get a list of available authentication methods for the user.
|
protected SshMessageStore |
Ssh2Channel.getMessageStore() |
byte[] |
Ssh2Context.getX11AuthenticationCookie() |
byte[] |
Ssh2Context.getX11RealCookie() |
boolean |
Ssh2Client.isAuthenticationSupported(String method)
Iterate over support mechanisms and return true only if the method
supplied is reported as supported by the remote device.
|
byte[] |
TransportProtocol.nextMessage(long timeout)
Get the next message.
|
byte[] |
AbstractClientTransport.nextMessage(long timeout) |
void |
Ssh2Client.openChannel(Ssh2Channel channel,
byte[] requestdata)
Additional method to open a custom SSH2 channel.
|
void |
Ssh2Client.openChannel(SshAbstractChannel channel)
Additional method to open a custom SSH2 channel.
|
SshTunnel |
Ssh2Client.openForwardingChannel(String hostname,
int port,
String listeningAddress,
int listeningPort,
String originatingHost,
int originatingPort,
SshTransport sock,
ChannelEventListener listener) |
SshClient |
Ssh2Client.openRemoteClient(String hostname,
int port,
String username) |
SshClient |
Ssh2Client.openRemoteClient(String hostname,
int port,
String username,
SshClientConnector con) |
SshSession |
Ssh2Client.openSessionChannel() |
SshSession |
Ssh2Client.openSessionChannel(ChannelEventListener listener) |
SshSession |
Ssh2Client.openSessionChannel(ChannelEventListener listener,
long timeout) |
Ssh2Session |
Ssh2Client.openSessionChannel(int windowspace,
int packetsize,
ChannelEventListener listener)
Additional method to open a session with SSH2 specific features.
|
Ssh2Session |
Ssh2Client.openSessionChannel(int windowspace,
int packetsize,
ChannelEventListener listener,
long timeout) |
SshSession |
Ssh2Client.openSessionChannel(long timeout) |
abstract void |
SshKeyExchangeClient.performClientExchange(String clientId,
String serverId,
byte[] clientKexInit,
byte[] serverKexInit)
Override to perform the client side key exchange.
|
protected boolean |
Ssh2Channel.processChannelMessage(SshChannelMessage msg)
Processes channel request messages by passing the request through to channelRequest()
.
|
protected void |
Ssh2Session.processExtendedData(int typecode,
int length,
SshChannelMessage msg) |
protected void |
Ssh2Channel.processExtendedData(int typecode,
int length,
SshChannelMessage msg)
Called when extended data arrives.
|
boolean |
GlobalRequestHandler.processGlobalRequest(GlobalRequest request)
Called when a supported global request has been recieved.
|
boolean |
TransportProtocol.processMessage(byte[] msg)
Process a message.
|
void |
Ssh2Client.processMessages(long timeout) |
protected void |
Ssh2Channel.processStandardData(int length,
SshChannelMessage msg)
Called when channel data arrives, by default this method makes the data
available in the channels InputStream.
|
byte[] |
AuthenticationProtocol.readMessage()
Read a message from the underlying transport layer.
|
boolean |
Ssh2Session.requestPseudoTerminal(String term,
int cols,
int rows,
int width,
int height) |
boolean |
Ssh2Session.requestPseudoTerminal(String term,
int cols,
int rows,
int width,
int height,
byte[] modes) |
boolean |
Ssh2Session.requestPseudoTerminal(String term,
int cols,
int rows,
int width,
int height,
PseudoTerminalModes terminalModes) |
int |
Ssh2Client.requestRemoteForwarding(String bindAddress,
int bindPort,
String hostToConnect,
int portToConnect,
ForwardingRequestListener listener) |
boolean |
Ssh2Client.sendGlobalRequest(GlobalRequest request,
boolean wantreply)
Sends a global request to the remote side.
|
boolean |
Ssh2Client.sendGlobalRequest(GlobalRequest request,
boolean wantreply,
long timeout)
Sends a global request to the remote side.
|
void |
AuthenticationProtocol.sendMessage(byte[] messg) |
void |
TransportProtocol.sendMessage(byte[] msg,
boolean isActivity)
Send a transport protocol message.
|
void |
AbstractClientTransport.sendMessage(byte[] byteArray,
boolean b) |
boolean |
Ssh2Channel.sendRequest(String requesttype,
boolean wantreply,
byte[] requestdata)
Sends a channel request.
|
boolean |
Ssh2Channel.sendRequest(String requesttype,
boolean wantreply,
byte[] requestdata,
boolean isActivity)
Sends a channel request.
|
void |
AuthenticationProtocol.sendRequest(String username,
String servicename,
String methodname,
byte[] requestdata)
Send an authentication request.
|
void |
Ssh2Context.setCipherPreferredPositionCS(String name,
int position) |
void |
Ssh2Context.setCipherPreferredPositionSC(String name,
int position) |
boolean |
Ssh2Session.setEnvironmentVariable(String name,
String value)
The SSH2 session supports the setting of environments variables however
in our experience no server to date allows unconditional setting of
variables.
|
void |
Ssh2Context.setKeyExchangePreferredPosition(String name,
int position) |
void |
Ssh2Context.setMacPreferredPositionCS(String name,
int position) |
void |
Ssh2Context.setMacPreferredPositionSC(String name,
int position) |
void |
Ssh2Context.setPreferredCipherCS(int[] order)
Set the preferred SC cipher order
|
void |
Ssh2Context.setPreferredCipherCS(String name)
Set the preferred cipher for the Client->Server stream.
|
void |
Ssh2Context.setPreferredCipherSC(int[] order)
Set the preferred SC cipher order
|
void |
Ssh2Context.setPreferredCipherSC(String name)
Set the preferred cipher for the Server->Client stream.
|
void |
Ssh2Context.setPreferredCompressionCS(String name)
Set the preferred compression for the Client->Server stream.
|
void |
Ssh2Context.setPreferredCompressionSC(String name)
Set the preferred compression for the Server->Client stream.
|
void |
Ssh2Context.setPreferredKeyExchange(String name)
Set the preferred key exchange method.
|
void |
Ssh2Context.setPreferredMacCS(int[] order)
Set the preferred CS Mac order
|
void |
Ssh2Context.setPreferredMacCS(String name)
Set the preferred mac for the Client->Server stream.
|
void |
Ssh2Context.setPreferredMacSC(int[] order)
Set the preferred SC Mac order
|
void |
Ssh2Context.setPreferredMacSC(String name)
Set the preferred mac for the Server->Client stream.
|
void |
Ssh2Context.setPreferredPublicKey(String name)
Set the preferred public key algorithm.
|
void |
Ssh2Context.setPublicKeyPreferredPosition(String name,
int position) |
byte[] |
SignatureGenerator.sign(SshPublicKey key,
byte[] data)
Sign the data using the private key of the public key provided.
|
void |
Ssh2Session.signal(String signal)
Send a signal to the remote process.
|
void |
TransportProtocol.startService(String servicename)
Request that the remote server starts a transport protocol service.
|
boolean |
Ssh2Session.startShell() |
boolean |
Ssh2Session.startSubsystem(String subsystem)
SSH2 supports special subsystems that are identified by a name rather
than a command string, an example of an SSH2 subsystem is SFTP.
|
void |
TransportProtocol.startTransportProtocol(SshTransport provider,
Ssh2Context context,
String localIdentification,
String remoteIdentification,
Ssh2Client client)
Starts the protocol on the provider.
|
Constructor and Description |
---|
AuthenticationProtocol(TransportProtocol transport)
Construct the protocol using the given transport
|
Ssh2Context()
Contructs a default context
|
Ssh2Context(SecurityPolicy securityPolicy) |
Modifier and Type | Method and Description |
---|---|
void |
ForwardingClient.allowX11Forwarding(String display)
Configure the forwarding client to manage X11 connections.
|
void |
ForwardingClient.allowX11Forwarding(String display,
File f)
Configure the forwarding client to manage X11 connections.
|
void |
ForwardingClient.allowX11Forwarding(String display,
String magicCookie)
Configure the forwarding client to manage X11 connections.
|
void |
ForwardingClient.cancelAllRemoteForwarding()
Stop all remote forwarding
|
void |
ForwardingClient.cancelAllRemoteForwarding(boolean killActiveTunnels)
Stop all remote forwarding.
|
void |
ForwardingClient.cancelRemoteForwarding(String bindAddress,
int bindPort)
Requests that the remote side stop listening for socket connections.
|
void |
ForwardingClient.cancelRemoteForwarding(String bindAddress,
int bindPort,
boolean killActiveTunnels)
Requests that the remote side stop listening for socket connections.
|
SshTransport |
ForwardingClient.ForwardingListener.createConnection(String hostToConnect,
int portToConnect) |
void |
ForwardingClient.exit() |
int |
ForwardingClient.requestRemoteForwarding(String addressToBind,
int portToBind,
String hostToConnect,
int portToConnect)
Requests that the remote side start listening for socket connections so
that they may be forwarded to to the local destination.
|
void |
ForwardingClient.SocketListener.start() |
int |
ForwardingClient.startLocalForwarding(String addressToBind,
int portToBind,
String hostToConnect,
int portToConnect)
Start's a local listening socket and forwards any connections made to the
to the remote side.
|
void |
ForwardingClient.stopAllLocalForwarding()
Stop all local forwarding
|
void |
ForwardingClient.stopAllLocalForwarding(boolean killActiveTunnels)
Stop all local forwarding
|
void |
ForwardingClient.stopLocalForwarding(String key,
boolean killActiveTunnels)
Stop a local listening socket from accepting connections.
|
void |
ForwardingClient.stopLocalForwarding(String bindAddress,
int bindPort)
Stops a local listening socket from accepting connections.
|
void |
ForwardingClient.stopLocalForwarding(String bindAddress,
int bindPort,
boolean killActiveTunnels)
Stops a local listening socket from accepting connections.
|
Modifier and Type | Method and Description |
---|---|
void |
PublicKeySubsystem.add(SshPublicKey key,
String comment)
Add a public key to the users list of acceptable keys.
|
void |
KnownHostsKeyVerification.addEntry(SshPublicKey key,
String comment,
String... names) |
void |
KnownHostsKeyVerification.allowHost(String host,
SshPublicKey key,
boolean always) |
void |
AbstractMultipleKnownHostsKeyVerification.allowHost(String host,
SshPublicKey pk,
boolean always)
Deprecated.
Allows a host key, optionally recording the key to the known_hosts file.
|
void |
AbstractKnownHostsKeyVerification.allowHost(String host,
SshPublicKey pk,
boolean always)
Deprecated.
Allows a host key, optionally recording the key to the known_hosts file.
|
void |
PublicKeySubsystem.associateCommand(SshPublicKey key,
String command)
Associate a command with an accepted public key.
|
static SshCertificate |
SshCertificateAuthority.generateCertificate(SshKeyPair key,
long serial,
int type,
String keyId,
List<String> validPrincipals,
int validityDays,
List<CriticalOption> criticalOptions,
List<CertificateExtension> extensions,
SshKeyPair signedBy) |
static SshCertificate |
SshCertificateAuthority.generateCertificate(SshKeyPair key,
long serial,
int type,
String keyId,
List<String> validPrincipals,
int validityDays,
Map<String,String> criticalOptions,
List<String> extensions,
SshKeyPair signedBy)
Deprecated.
This method does not handle extensions correctly. Use alternative method that takes CertificateExtension
instances for extensions and critical options.
|
static SshCertificate |
SshCertificateAuthority.generateCertificate(SshKeyPair key,
long serial,
int type,
String keyId,
String principal,
int validityDays,
List<CertificateExtension> extensions,
SshKeyPair signedBy) |
static SshCertificate |
SshCertificateAuthority.generateCertificate(SshKeyPair key,
long serial,
int type,
String keyId,
String principal,
int validityDays,
SshKeyPair signedBy) |
static OpenSshCertificate |
SshCertificateAuthority.generateCertificate(SshPublicKey key,
long serial,
int type,
String keyId,
List<String> validPrincipals,
int validityDays,
List<CriticalOption> criticalOptions,
List<CertificateExtension> extensions,
SshKeyPair signedBy) |
static OpenSshCertificate |
SshCertificateAuthority.generateCertificate(SshPublicKey key,
long serial,
int type,
String keyId,
String principal,
int validityDays,
List<CertificateExtension> extensions,
SshKeyPair signedBy) |
static OpenSshCertificate |
SshCertificateAuthority.generateCertificate(SshPublicKey key,
long serial,
int type,
String keyId,
String principal,
int validityDays,
SshKeyPair signedBy) |
static SshCertificate |
SshCertificateAuthority.generateHostCertificate(SshKeyPair key,
long serial,
String hostname,
int validityDays,
SshKeyPair signedBy) |
static OpenSshCertificate |
SshCertificateAuthority.generateHostCertificate(SshPublicKey key,
long serial,
String hostname,
int validityDays,
SshKeyPair signedBy) |
static SshKeyPair |
SshKeyPairGenerator.generateKeyPair() |
static SshKeyPair |
SshKeyPairGenerator.generateKeyPair(String algorithm) |
static SshKeyPair |
SshKeyPairGenerator.generateKeyPair(String algorithm,
int bits)
Generates a new key pair.
|
static SshCertificate |
SshCertificateAuthority.generateUserCertificate(SshKeyPair key,
long serial,
String principalName,
int validityDays,
SshKeyPair signedBy) |
static OpenSshCertificate |
SshCertificateAuthority.generateUserCertificate(SshPublicKey key,
long serial,
String principalName,
int validityDays,
SshKeyPair signedBy) |
Set<String> |
KnownHostsKeyVerification.getAlgorithmsForHost(String host) |
boolean |
KnownHostsKeyVerification.isKnownHost(String host,
SshPublicKey key) |
SshPublicKey[] |
PublicKeySubsystem.list()
List all of the users acceptable keys.
|
void |
KnownHostsKeyVerification.load(InputStream in) |
protected void |
KnownHostsKeyVerification.onHostKeyMismatch(String host,
List<SshPublicKey> allowedHostKey,
SshPublicKey actualHostKey)
Called by the
verifyHost method when the host key supplied
by the host does not match the current key recording in the known hosts
file. |
protected void |
KnownHostsFile.onHostKeyMismatch(String host,
List<SshPublicKey> allowedHostKey,
SshPublicKey actualHostKey) |
protected void |
ConsoleKnownHostsFile.onHostKeyMismatch(String host,
List<SshPublicKey> allowedHostKey,
SshPublicKey actual) |
abstract void |
AbstractMultipleKnownHostsKeyVerification.onHostKeyMismatch(String host,
List<SshPublicKey> allowedHostKey,
SshPublicKey actualHostKey)
Deprecated.
Called by the
verifyHost method when the host key supplied
by the host does not match the current key recording in the known hosts
file. |
abstract void |
AbstractKnownHostsKeyVerification.onHostKeyMismatch(String host,
SshPublicKey allowedHostKey,
SshPublicKey actualHostKey)
Deprecated.
Called by the
verifyHost method when the host key supplied
by the host does not match the current key recording in the known hosts
file. |
protected void |
KnownHostsKeyVerification.onInvalidHostEntry(String entry) |
protected void |
KnownHostsFile.onInvalidHostEntry(String entry) |
protected void |
ConsoleMultipleKnownHostsKeyVerification.onInvalidHostEntry(String entry)
Deprecated.
|
protected void |
ConsoleKnownHostsKeyVerification.onInvalidHostEntry(String entry)
Deprecated.
|
protected void |
ConsoleKnownHostsFile.onInvalidHostEntry(String entry) |
protected void |
AbstractMultipleKnownHostsKeyVerification.onInvalidHostEntry(String entry)
Deprecated.
|
protected void |
AbstractKnownHostsKeyVerification.onInvalidHostEntry(String entry)
Deprecated.
|
protected void |
KnownHostsKeyVerification.onUnknownHost(String host,
SshPublicKey key)
Called by the
verifyHost method when the host key supplied
is not recorded in the known_hosts file. |
protected void |
KnownHostsFile.onUnknownHost(String host,
SshPublicKey key) |
abstract void |
AbstractMultipleKnownHostsKeyVerification.onUnknownHost(String host,
SshPublicKey key)
Deprecated.
Called by the
verifyHost method when the host key supplied
is not recorded in the known_hosts file. |
abstract void |
AbstractKnownHostsKeyVerification.onUnknownHost(String host,
SshPublicKey key)
Deprecated.
Called by the
verifyHost method when the host key supplied
is not recorded in the known_hosts file. |
void |
PublicKeySubsystem.remove(SshPublicKey key)
Remove a public key from the users list of acceptable keys.
|
void |
KnownHostsKeyVerification.removeEntries(String... hosts) |
void |
KnownHostsKeyVerification.removeEntries(String host)
Removes an allowed host.
|
void |
KnownHostsKeyVerification.removeEntries(String host,
SshPublicKey key) |
void |
KnownHostsKeyVerification.updateHostKey(String host,
SshPublicKey key) |
boolean |
X509HostKeyVerification.verifyHost(String host,
SshPublicKey pk) |
boolean |
KnownHostsKeyVerification.verifyHost(String host,
SshPublicKey pk)
Verifies a host key against the list of known_hosts.
|
boolean |
HostKeyVerificationManager.verifyHost(String host,
SshPublicKey pk) |
boolean |
AbstractMultipleKnownHostsKeyVerification.verifyHost(String host,
SshPublicKey pk)
Deprecated.
Verifies a host key against the list of known_hosts.
|
boolean |
AbstractKnownHostsKeyVerification.verifyHost(String host,
SshPublicKey pk)
Deprecated.
Verifies a host key against the list of known_hosts.
|
Constructor and Description |
---|
AbstractKnownHostsKeyVerification()
Deprecated.
Construct a known_hosts database based on the default path of
~/.ssh/known_hosts.
|
AbstractKnownHostsKeyVerification(String knownhosts)
Deprecated.
Constructs a known_hosts database based on the path provided.
|
AbstractMultipleKnownHostsKeyVerification()
Deprecated.
Construct a known_hosts database based on the default path of
~/.ssh/known_hosts.
|
AbstractMultipleKnownHostsKeyVerification(String knownhosts)
Deprecated.
Constructs a known_hosts database based on the path provided.
|
ConsoleKnownHostsFile() |
ConsoleKnownHostsFile(File file) |
ConsoleKnownHostsKeyVerification()
Deprecated.
Constructs the verification instance with the default known_hosts file
from $HOME/.ssh/known_hosts.
|
ConsoleKnownHostsKeyVerification(String knownhosts)
Deprecated.
Constructs the verification instance with the specified known_hosts
file.
|
ConsoleMultipleKnownHostsKeyVerification()
Deprecated.
Constructs the verification instance with the default known_hosts file
from $HOME/.ssh/known_hosts.
|
ConsoleMultipleKnownHostsKeyVerification(String knownhosts)
Deprecated.
Constructs the verification instance with the specified known_hosts
file.
|
KnownHostsFile() |
KnownHostsFile(File file) |
KnownHostsKeyVerification(InputStream in) |
KnownHostsKeyVerification(String knownhosts) |
PublicKeySubsystem(Ssh2Session session) |
PublicKeySubsystem(Ssh2Session session,
int timeout) |
Modifier and Type | Method and Description |
---|---|
void |
ScpClient.exit() |
void |
ScpClient.get(String localDir,
String[] remoteFiles,
boolean recursive)
Downloads an array of remote files to the local computer.
|
void |
ScpClient.get(String localFile,
String[] remoteFiles,
boolean recursive,
FileTransferProgress progress) |
void |
ScpClient.get(String localFile,
String remoteFile,
boolean recursive)
Downloads a remote file onto the local computer.
|
void |
ScpClient.get(String localFile,
String remoteFile,
boolean recursive,
FileTransferProgress progress) |
void |
ScpClient.put(String[] localFiles,
String remoteFile,
boolean recursive)
Uploads an array of local files onto the remote server.
|
void |
ScpClient.put(String[] localFiles,
String remoteFile,
boolean recursive,
FileTransferProgress progress)
Uploads an array of local files onto the remote server.
|
void |
ScpClient.put(String localFile,
String remoteFile,
boolean recursive)
Uploads a local file onto the remote server.
|
void |
ScpClient.put(String localFileRegExp,
String remoteFile,
boolean recursive,
FileTransferProgress progress)
pattern
matches the files in the local directory using "local" as a glob Regular
Expression.
|
void |
ScpClient.putFile(String localFile,
String remoteFile,
boolean recursive,
FileTransferProgress progress,
boolean remoteIsDir) |
Constructor and Description |
---|
ScpEngine(String cmd,
SshSession session)
Contruct the channel with the specified scp command.
|
Modifier and Type | Method and Description |
---|---|
void |
SftpClient.append(InputStream in,
String remote) |
void |
SftpClient.append(InputStream in,
String remote,
FileTransferProgress progress) |
void |
SftpClient.append(String local,
String remote) |
void |
SftpClient.append(String local,
String remote,
FileTransferProgress progress) |
void |
SftpClient.cd(String dir)
Changes the working directory on the remote server, or the user's default
directory if
null or any empty string is provided as the
directory path. |
void |
SftpClient.cd(String dir,
boolean disableAttributeChecks)
Changes the working directory on the remote server, or the user's default
directory if
null or any empty string is provided as the
directory path. |
void |
SftpClient.cdup()
Change the working directory to the parent directory
|
void |
SftpClient.chgrp(String gid,
String path)
Sets the group ID for the file or directory.
|
void |
SftpClient.chmod(int permissions,
String path)
Changes the access permissions or modes of the specified file or
directory.
|
void |
SftpClient.chown(String uid,
String path)
Sets the user ID to owner for the file or directory.
|
DirectoryOperation |
SftpClient.copyLocalDirectory(String localdir,
String remotedir,
boolean recurse,
boolean sync,
boolean commit,
FileTransferProgress progress)
Deprecated.
Use putLocalDirectory instead.
|
void |
SftpClient.copyRemoteData(SftpFile sourceFile,
UnsignedInteger64 fromOffset,
UnsignedInteger64 length,
SftpFile destinationFile,
UnsignedInteger64 toOffset) |
DirectoryOperation |
SftpClient.copyRemoteDirectory(String remotedir,
String localdir,
boolean recurse,
boolean sync,
boolean commit,
FileTransferProgress progress)
Deprecated.
Use getRemoteDirectory instead
|
void |
SftpClient.copyRemoteFile(String sourceFile,
String destinationFile,
boolean overwriteDestination) |
protected byte[] |
SftpClient.doCheckFileHandle(String filename,
long offset,
long length,
RemoteHash algorithm) |
protected byte[] |
SftpClient.doCheckHashHandle(byte[] handle,
long offset,
long length,
RemoteHash algorithm) |
void |
SftpClient.exit()
Close the SFTP client.
|
static String |
SftpClient.formatLongname(SftpFile file)
Format a String with the details of the file.
|
SftpFileAttributes |
SftpClient.get(String path)
Download the remote file to the local computer
|
SftpFileAttributes |
SftpClient.get(String path,
boolean resume)
Download the remote file to the local computer
|
SftpFileAttributes |
SftpClient.get(String path,
FileTransferProgress progress)
Download the remote file to the local computer.
|
SftpFileAttributes |
SftpClient.get(String path,
FileTransferProgress progress,
boolean resume)
Download the remote file to the local computer.
|
SftpFileAttributes |
SftpClient.get(String remote,
OutputStream local)
Download the remote file into an OutputStream.
|
SftpFileAttributes |
SftpClient.get(String remote,
OutputStream local,
FileTransferProgress progress)
Download the remote file writing it to the specified
OutputStream . |
SftpFileAttributes |
SftpClient.get(String remote,
OutputStream local,
FileTransferProgress progress,
long position)
Download the remote file writing it to the specified
OutputStream . |
SftpFileAttributes |
SftpClient.get(String remote,
OutputStream local,
long position)
Download the remote file into an OutputStream.
|
SftpFileAttributes |
SftpClient.get(String remote,
String local)
Download the remote file into the local file.
|
SftpFileAttributes |
SftpClient.get(String remote,
String local,
boolean resume)
Download the remote file into the local file.
|
SftpFileAttributes |
SftpClient.get(String remote,
String local,
FileTransferProgress progress)
Download the remote file to the local computer.
|
SftpFileAttributes |
SftpClient.get(String remote,
String local,
FileTransferProgress progress,
boolean resume)
Download the remote file to the local computer.
|
String |
SftpClient.getAbsolutePath(String path)
Get the absolute path for a file.
|
String |
SftpClient.getDefaultDirectory()
Get the default directory (or HOME directory)
|
SftpFile[] |
SftpClient.getFiles(String remote)
Download the remote files to the local computer
|
SftpFile[] |
SftpClient.getFiles(String remote,
boolean resume)
Download the remote files to the local computer
|
SftpFile[] |
SftpClient.getFiles(String remote,
FileTransferProgress progress)
Download the remote files to the local computer.
|
SftpFile[] |
SftpClient.getFiles(String remote,
FileTransferProgress progress,
boolean resume)
Download the remote files to the local computer.
|
SftpFile[] |
SftpClient.getFiles(String remote,
String local)
Download the remote files into the local file.
|
SftpFile[] |
SftpClient.getFiles(String remote,
String local,
boolean resume)
Download the remote files into the local file.
|
SftpFile[] |
SftpClient.getFiles(String remote,
String local,
FileTransferProgress progress,
boolean resume)
Download the remote file to the local computer.
|
String |
SftpClient.getHomeDirectory(String username) |
InputStream |
SftpClient.getInputStream(String remotefile)
Create an InputStream for reading a remote file.
|
InputStream |
SftpClient.getInputStream(String remotefile,
long position)
Create an InputStream for reading a remote file.
|
OutputStream |
SftpClient.getOutputStream(String remotefile)
Create an OutputStream for writing to a remote file.
|
DirectoryOperation |
SftpClient.getRemoteDirectory(String remotedir,
String localdir,
boolean recurse,
boolean sync,
boolean commit,
FileTransferProgress progress)
Copy the contents of a remote directory to a local directory
|
byte[] |
SftpClient.getRemoteHash(byte[] handle)
Deprecated.
|
byte[] |
SftpClient.getRemoteHash(byte[] handle,
long offset,
long length,
byte[] quickCheck)
Deprecated.
|
byte[] |
SftpClient.getRemoteHash(byte[] handle,
long offset,
long length,
RemoteHash algorithm) |
byte[] |
SftpClient.getRemoteHash(byte[] handle,
RemoteHash algorithm) |
byte[] |
SftpClient.getRemoteHash(String remoteFile)
Deprecated.
|
byte[] |
SftpClient.getRemoteHash(String remoteFile,
long offset,
long length,
byte[] quickCheck)
Deprecated.
|
byte[] |
SftpClient.getRemoteHash(String path,
long offset,
long length,
RemoteHash algorithm) |
byte[] |
SftpClient.getRemoteHash(String path,
RemoteHash algorithm) |
String |
SftpClient.getTemporaryFolder() |
long |
DirectoryOperation.getTransferSize()
Get the total number of bytes that this operation will transfer
|
void |
SftpClient.hardlink(String src,
String dst) |
boolean |
SftpClient.isDirectoryOrLinkedDirectory(SftpFile file)
Determine whether the file object is pointing to a symbolic link that is
pointing to a directory.
|
SftpFile[] |
SftpClient.ls()
Deprecated.
use ls(int maximumFiles) instead.
|
SftpFile[] |
SftpClient.ls(int maximumFiles)
List the contents of the current remote working directory.
|
SftpFile[] |
SftpClient.ls(String path)
Deprecated.
use ls(String path, int maximumFiles) instead.
|
SftpFile[] |
SftpClient.ls(String filter,
boolean regexFilter,
int maximumFiles) |
SftpFile[] |
SftpClient.ls(String path,
int maximumFiles)
List the contents remote directory.
|
SftpFile[] |
SftpClient.ls(String path,
String filter,
boolean regexFilter,
int maximumFiles) |
Iterator<SftpFile> |
SftpClient.lsIterator()
Return an iterator for the current working directory.
|
Iterator<SftpFile> |
SftpClient.lsIterator(String path)
Return an iterator for the path provided.
|
String |
SftpClient.makeTemporaryFolder() |
String[] |
RegularExpressionMatching.matchFileNamesWithPattern(File[] files,
String fileNameRegExp)
returns each of the files that match the pattern fileNameRegExp
|
String[] |
Perl5RegExpMatching.matchFileNamesWithPattern(File[] files,
String pattern)
compiles pattern into a regular expression and pattern
matches on each file's name, and returns those that match.
|
String[] |
NoRegExpMatching.matchFileNamesWithPattern(File[] files,
String fileNameRegExp)
opens and returns the requested filename string
|
String[] |
GlobRegExpMatching.matchFileNamesWithPattern(File[] files,
String pattern)
compiles pattern into a regular expression and pattern
matches on each file's name, and returns those that match.
|
SftpFile[] |
RegularExpressionMatching.matchFilesWithPattern(SftpFile[] files,
String fileNameRegExp)
returns each of the SftpFiles that match the pattern fileNameRegExp
|
SftpFile[] |
Perl5RegExpMatching.matchFilesWithPattern(SftpFile[] files,
String pattern)
compiles pattern into a regular expression and pattern
matches on each file's name, and returns those that match.
|
SftpFile[] |
NoRegExpMatching.matchFilesWithPattern(SftpFile[] files,
String fileNameRegExp)
returns files
|
SftpFile[] |
GlobRegExpMatching.matchFilesWithPattern(SftpFile[] files,
String pattern)
compiles pattern into a regular expression and pattern
matches on each file's name, and returns those that match.
|
SftpFile[] |
SftpClient.matchRemoteFiles(String remote)
Called by getFileMatches() to do regular expression pattern matching on
the files in 'remote''s parent directory.
|
void |
SftpClient.mkdir(String dir)
Creates a new directory on the remote server.
|
void |
SftpClient.mkdirs(String dir)
Create a directory or set of directories.
|
SftpFile |
SftpClient.openFile(String fileName) |
void |
SftpClient.put(InputStream in,
String remote)
Upload the contents of an InputStream to the remote computer.
|
void |
SftpClient.put(InputStream in,
String remote,
FileTransferProgress progress)
Upload a file to the remote computer reading from the specified
InputStream . |
void |
SftpClient.put(InputStream in,
String remote,
FileTransferProgress progress,
long position) |
void |
SftpClient.put(InputStream in,
String remote,
long position)
Upload the contents of an InputStream to the remote computer.
|
void |
SftpClient.put(String local)
Upload a file to the remote computer
|
void |
SftpClient.put(String local,
boolean resume)
Upload a file to the remote computer
|
void |
SftpClient.put(String local,
FileTransferProgress progress)
Upload a file to the remote computer.
|
void |
SftpClient.put(String local,
FileTransferProgress progress,
boolean resume)
Upload a file to the remote computer.
|
void |
SftpClient.put(String local,
String remote)
Upload a file to the remote computer
|
void |
SftpClient.put(String local,
String remote,
boolean resume)
Upload a file to the remote computer
|
void |
SftpClient.put(String local,
String remote,
FileTransferProgress progress)
Upload a file to the remote computer.
|
void |
SftpClient.put(String local,
String remote,
FileTransferProgress progress,
boolean resume)
Upload a file to the remote computer.
|
void |
SftpClient.putFiles(String local)
Upload the contents of an InputStream to the remote computer.
|
void |
SftpClient.putFiles(String local,
boolean resume)
Upload files to the remote computer
|
void |
SftpClient.putFiles(String local,
FileTransferProgress progress)
Upload files to the remote computer
|
void |
SftpClient.putFiles(String local,
FileTransferProgress progress,
boolean resume)
Upload files to the remote computer
|
void |
SftpClient.putFiles(String local,
String remote)
Upload files to the remote computer
|
void |
SftpClient.putFiles(String local,
String remote,
boolean resume)
Upload files to the remote computer
|
void |
SftpClient.putFiles(String local,
String remote,
FileTransferProgress progress)
Upload files to the remote computer.
|
void |
SftpClient.putFiles(String local,
String remote,
FileTransferProgress progress,
boolean resume)
make local copies of some of the variables, then call putfilematches,
which calls "put" on each file that matches the regexp local.
|
DirectoryOperation |
SftpClient.putLocalDirectory(String localdir,
String remotedir,
boolean recurse,
boolean sync,
boolean commit,
FileTransferProgress progress)
Copy the contents of a local directory into a remote directory.
|
void |
SftpClient.quit()
Close the SFTP client.
|
void |
SftpClient.rename(String oldpath,
String newpath)
Rename a file on the remote computer.
|
void |
SftpClient.rename(String oldpath,
String newpath,
boolean posix)
Rename a file on the remote computer, optionally using posix semantics that allow files to be renamed
even if the destination path exists.
|
void |
SftpClient.rm(String path)
Remove a file or directory from the remote computer.
|
void |
SftpClient.rm(String path,
boolean force,
boolean recurse)
Remove a file or directory on the remote computer with options to force
deletion of existing files and recursion.
|
SftpFileAttributes |
SftpClient.stat(String path)
Returns the attributes of the file from the remote computer.
|
SftpFileAttributes |
SftpClient.statLink(String path)
Returns the attributes of the link from the remote computer.
|
StatVfs |
SftpClient.statVFS(String path) |
void |
SftpClient.symlink(String path,
String link)
Create a symbolic link on the remote computer.
|
void |
SftpClient.umask(String umask)
Sets the umask for this client.
|
boolean |
SftpClient.verifyFiles(String localFile,
String remoteFile)
Verify a local and remote file.
|
boolean |
SftpClient.verifyFiles(String localFile,
String remoteFile,
long offset,
long length)
Verify a local and remote file.
|
boolean |
SftpClient.verifyFiles(String localFile,
String remoteFile,
long offset,
long length,
RemoteHash algorithm) |
boolean |
SftpClient.verifyFiles(String localFile,
String remoteFile,
RemoteHash algorithm) |
Constructor and Description |
---|
SftpClient(int timeout,
SshClient ssh) |
SftpClient(int timeout,
SshSession session) |
SftpClient(SshClient ssh) |
SftpClient(SshClient ssh,
ChannelEventListener listener) |
SftpClient(SshClient ssh,
ChannelEventListener listener,
int timeout) |
SftpClient(SshClient ssh,
int version)
Constructs the SFTP client.
|
SftpClient(SshClient ssh,
int version,
ChannelEventListener listener)
Constructs the SFTP client with a given channel event listener.
|
SftpClient(SshClient ssh,
int version,
int timeout)
Constructs the SFTP client.
|
SftpClient(SshClient ssh,
int version,
int timeout,
ChannelEventListener listener)
Constructs the SFTP client with a given channel event listener.
|
SftpClient(SshSession session) |
SftpClient(SshSession session,
int version) |
SftpClient(SshSession session,
int version,
int timeout) |
Copyright © 2024. All rights reserved.