Modifier and Type | Method and Description |
---|---|
SshAgent |
SshAgentFactory.createClient(Session session,
FactoryManager manager)
Create an SshAgent that can be used on the client side by the authentication process to send possible keys.
|
Modifier and Type | Method and Description |
---|---|
protected SshAgentServer |
DefaultAgentForwardSupport.createSshAgentServer(ConnectionService service,
Session session) |
Modifier and Type | Method and Description |
---|---|
Channel |
ChannelAgentForwardingFactory.createChannel(Session session) |
SshAgent |
ProxyAgentFactory.createClient(Session session,
FactoryManager manager) |
SshAgent |
LocalAgentFactory.createClient(Session session,
FactoryManager manager) |
Modifier and Type | Method and Description |
---|---|
protected void |
ChannelSession.sendEnvVariables(Session session) |
Modifier and Type | Method and Description |
---|---|
protected RequestHandler.Result |
OpenSshHostKeysHandler.handleHostKeys(Session session,
Collection<? extends PublicKey> keys,
boolean wantReply,
Buffer buffer) |
Modifier and Type | Method and Description |
---|---|
protected void |
DHGClient.verifyCertificate(Session session,
OpenSshCertificate openSshKey) |
Constructor and Description |
---|
AbstractDHClientKeyExchange(Session session) |
DHGClient(DHFactory factory,
Session session) |
DHGEXClient(DHFactory factory,
Session session) |
Modifier and Type | Interface and Description |
---|---|
interface |
ClientSession
An authenticated session to a given SSH server.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractClientSession
Provides default implementations of
ClientSession related methods |
class |
ClientSessionImpl
The default implementation of a
ClientSession |
Modifier and Type | Method and Description |
---|---|
Service |
ClientConnectionServiceFactory.create(Session session) |
Service |
ClientUserAuthServiceFactory.create(Session session) |
Constructor and Description |
---|
ClientUserAuthService(Session s) |
Modifier and Type | Method and Description |
---|---|
static Service |
ServiceFactory.create(Collection<? extends ServiceFactory> factories,
String name,
Session session)
Create an instance of the specified name by looking up the needed factory in the list (case insensitive.
|
Service |
ServiceFactory.create(Session session) |
Modifier and Type | Method and Description |
---|---|
Session |
AbstractChannel.getSession() |
Modifier and Type | Method and Description |
---|---|
Channel |
ChannelFactory.createChannel(Session session) |
static Channel |
ChannelFactory.createChannel(Session session,
Collection<? extends ChannelFactory> factories,
String name) |
void |
AbstractChannel.handleChannelRegistrationResult(ConnectionService service,
Session session,
long channelId,
boolean registered) |
void |
Channel.handleChannelRegistrationResult(ConnectionService service,
Session session,
long id,
boolean registered)
Invoked after being successfully registered by the connection service - should throw a
RuntimeException
if not registered |
void |
AbstractChannel.init(ConnectionService service,
Session session,
long id) |
void |
Channel.init(ConnectionService service,
Session session,
long id)
Invoked when the local channel is initial created
|
Modifier and Type | Method and Description |
---|---|
Session |
DefaultForwarder.getSession() |
Modifier and Type | Method and Description |
---|---|
default void |
PortForwardingEventListener.establishedDynamicTunnel(Session session,
SshdSocketAddress local,
SshdSocketAddress boundAddress,
Throwable reason)
Signals a successful/failed attempt to establish a dynamic port forwarding
|
default void |
PortForwardingEventListener.establishedExplicitTunnel(Session session,
SshdSocketAddress local,
SshdSocketAddress remote,
boolean localForwarding,
SshdSocketAddress boundAddress,
Throwable reason)
Signals a successful/failed attempt to establish a local/remote port forwarding
|
default void |
PortForwardingEventListener.establishingDynamicTunnel(Session session,
SshdSocketAddress local)
Signals the attempt to establish a dynamic port forwarding
|
default void |
PortForwardingEventListener.establishingExplicitTunnel(Session session,
SshdSocketAddress local,
SshdSocketAddress remote,
boolean localForwarding)
Signals the attempt to establish a local/remote port forwarding
|
default void |
PortForwardingEventListener.tearingDownDynamicTunnel(Session session,
SshdSocketAddress address)
Signals a request to tear down a dynamic forwarding
|
default void |
PortForwardingEventListener.tearingDownExplicitTunnel(Session session,
SshdSocketAddress address,
boolean localForwarding,
SshdSocketAddress remoteAddress)
Signals a request to tear down a local/remote port forwarding
|
default void |
PortForwardingEventListener.tornDownDynamicTunnel(Session session,
SshdSocketAddress address,
Throwable reason)
Signals a successful/failed request to tear down a dynamic port forwarding
|
default void |
PortForwardingEventListener.tornDownExplicitTunnel(Session session,
SshdSocketAddress address,
boolean localForwarding,
SshdSocketAddress remoteAddress,
Throwable reason)
Signals a successful/failed request to tear down a local/remote port forwarding
|
Modifier and Type | Method and Description |
---|---|
protected abstract RequestHandler.Result |
AbstractOpenSshHostKeysHandler.handleHostKeys(Session session,
Collection<? extends PublicKey> keys,
boolean wantReply,
Buffer buffer) |
Modifier and Type | Method and Description |
---|---|
KeyExchange |
KeyExchangeFactory.createKeyExchange(Session session) |
Modifier and Type | Method and Description |
---|---|
Session |
AbstractDHKeyExchange.getSession() |
Constructor and Description |
---|
AbstractDHKeyExchange(Session session) |
Modifier and Type | Method and Description |
---|---|
void |
DefaultServerKexExtensionHandler.collectExtensions(Session session,
KexExtensionHandler.KexPhase phase,
BiConsumer<String,Object> marshaller)
Collects extension info records, handing them off to the given
marshaller for writing into an
KexExtensions.SSH_MSG_EXT_INFO message. |
default boolean |
KexExtensionHandler.handleKexCompressionMessage(Session session,
Buffer buffer)
Parses the
SSH_MSG_NEWCOMPRESS message. |
default void |
KexExtensionHandler.handleKexExtensionNegotiation(Session session,
KexProposalOption option,
String nValue,
Map<KexProposalOption,String> c2sOptions,
String cValue,
Map<KexProposalOption,String> s2cOptions,
String sValue)
Invoked during the KEX negotiation phase to inform about option being negotiated.
|
default boolean |
KexExtensionHandler.handleKexExtensionRequest(Session session,
int index,
int count,
String name,
byte[] data)
Invoked by
KexExtensionHandler.handleKexExtensionsMessage(Session, Buffer) in order to handle a specific extension. |
boolean |
DefaultClientKexExtensionHandler.handleKexExtensionRequest(Session session,
int index,
int count,
String name,
byte[] data) |
default boolean |
KexExtensionHandler.handleKexExtensionsMessage(Session session,
Buffer buffer)
Parses the
SSH_MSG_EXT_INFO message. |
default void |
KexExtensionHandler.handleKexInitProposal(Session session,
boolean initiator,
Map<KexProposalOption,String> proposal)
Invoked when a peer is ready to send the KEX options proposal or has received such a proposal.
|
void |
DefaultServerKexExtensionHandler.handleKexInitProposal(Session session,
boolean initiator,
Map<KexProposalOption,String> proposal) |
protected void |
DefaultClientKexExtensionHandler.handleServerSignatureAlgorithms(Session session,
Collection<String> serverAlgorithms)
Perform updates after a server-sig-algs extension has been received.
|
default boolean |
KexExtensionHandler.isKexExtensionsAvailable(Session session,
KexExtensionHandler.AvailabilityPhase phase) |
boolean |
DefaultClientKexExtensionHandler.isKexExtensionsAvailable(Session session,
KexExtensionHandler.AvailabilityPhase phase) |
default void |
KexExtensionHandler.sendKexExtensions(Session session,
KexExtensionHandler.KexPhase phase)
Invoked in order to allow the handler to send an
SSH_MSG_EXT_INFO message. |
void |
DefaultServerKexExtensionHandler.sendKexExtensions(Session session,
KexExtensionHandler.KexPhase phase) |
Modifier and Type | Interface and Description |
---|---|
interface |
SessionHolder<S extends Session> |
Modifier and Type | Method and Description |
---|---|
Session |
SessionWorkBuffer.getSession() |
Modifier and Type | Method and Description |
---|---|
default boolean |
SessionDisconnectHandler.handleAuthCountDisconnectReason(Session session,
Service service,
String serviceName,
String method,
String user,
int currentAuthCount,
int maxAuthCount)
Invoked if the number of authentication attempts exceeded the maximum allowed
|
default boolean |
SessionDisconnectHandler.handleAuthParamsDisconnectReason(Session session,
Service service,
String authUser,
String username,
String authService,
String serviceName)
Invoked if the authentication parameters changed in mid-authentication process.
|
default void |
ReservedSessionMessagesHandler.handleDebugMessage(Session session,
Buffer buffer)
Invoked when an
SSH_MSG_DEBUG packet is received |
default void |
ReservedSessionMessagesHandler.handleIgnoreMessage(Session session,
Buffer buffer)
Invoked when an
SSH_MSG_IGNORE packet is received |
default boolean |
SessionDisconnectHandler.handleKexDisconnectReason(Session session,
Map<KexProposalOption,String> c2sOptions,
Map<KexProposalOption,String> s2cOptions,
Map<KexProposalOption,String> negotiatedGuess,
KexProposalOption option)
Invoked if after KEX negotiation parameters resolved one of the options violates some internal constraint (e.g.,
cannot negotiate a value, or RFC 8308 - section
2.2).
|
default boolean |
SessionDisconnectHandler.handleSessionsCountDisconnectReason(Session session,
Service service,
String username,
int currentSessionCount,
int maxSessionCount)
Called to inform that the maximum allowed concurrent sessions threshold has been exceeded.
|
default boolean |
SessionDisconnectHandler.handleTimeoutDisconnectReason(Session session,
TimeoutIndicator timeoutStatus)
Invoked when an internal timeout has expired (e.g., authentication, idle).
|
default boolean |
ReservedSessionMessagesHandler.handleUnimplementedMessage(Session session,
int cmd,
Buffer buffer)
Invoked when a packet with an un-implemented message is received - including
SSH_MSG_UNIMPLEMENTED itself |
default boolean |
SessionDisconnectHandler.handleUnsupportedServiceDisconnectReason(Session session,
int cmd,
String serviceName,
Buffer buffer)
Invoked when a request has been made related to an unknown SSH service as described in
RFC 4253 - section 10.
|
static <T> T |
Session.resolveAttribute(Session session,
AttributeRepository.AttributeKey<T> key)
Attempts to use the session's attribute, if not found then tries the factory manager
|
default IoWriteFuture |
ReservedSessionMessagesHandler.sendIdentification(Session session,
String version,
List<String> extraLines)
Send the initial version exchange identification in and independent manner
|
default IoWriteFuture |
ReservedSessionMessagesHandler.sendKexInitRequest(Session session,
Map<KexProposalOption,String> proposal,
Buffer packet)
Invoked before sending the
SSH_MSG_KEXINIT packet |
default void |
SessionListener.sessionClosed(Session session)
A session has been closed
|
default void |
SessionListener.sessionCreated(Session session)
A new session just been created
|
default void |
SessionListener.sessionDisconnect(Session session,
int reason,
String msg,
String language,
boolean initiator)
Invoked when
SSH_MSG_DISCONNECT message was sent/received |
default void |
SessionListener.sessionEstablished(Session session)
An initial session connection has been established - Caveat emptor: the main difference between this
callback and
SessionListener.sessionCreated(Session) is that when this callback is called, the session is not yet fully
initialized so not all API(s) will respond as expected. |
default void |
SessionListener.sessionEvent(Session session,
SessionListener.Event event)
An event has been triggered
|
default void |
SessionListener.sessionException(Session session,
Throwable t)
An exception was caught and the session will be closed (if not already so).
|
default void |
SessionListener.sessionNegotiationEnd(Session session,
Map<KexProposalOption,String> clientProposal,
Map<KexProposalOption,String> serverProposal,
Map<KexProposalOption,String> negotiatedOptions,
Throwable reason)
Signals the end of the negotiation options handling
|
default void |
SessionListener.sessionNegotiationOptionsCreated(Session session,
Map<KexProposalOption,String> proposal) |
default void |
SessionListener.sessionNegotiationStart(Session session,
Map<KexProposalOption,String> clientProposal,
Map<KexProposalOption,String> serverProposal)
Signals the start of the negotiation options handling
|
default void |
SessionListener.sessionPeerIdentificationLine(Session session,
String line,
List<String> extraLines)
Successfully read a line as part of the initial peer identification
|
default void |
SessionListener.sessionPeerIdentificationReceived(Session session,
String version,
List<String> extraLines)
The peer's identification version was received
|
default void |
SessionListener.sessionPeerIdentificationSend(Session session,
String version,
List<String> extraLines)
About to send identification to peer
|
Constructor and Description |
---|
SessionWorkBuffer(Session session) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractSession
The AbstractSession handles all the basic SSH protocol such as key exchange, authentication, encoding and decoding.
|
class |
SessionHelper
Contains split code in order to make
AbstractSession class smaller |
Modifier and Type | Field and Description |
---|---|
protected Session |
CurrentService.session
The session this
CurrentService belongs to. |
Modifier and Type | Method and Description |
---|---|
protected AgentForwardSupport |
AbstractConnectionService.createAgentForwardSupport(Session session) |
protected Forwarder |
AbstractConnectionService.createForwardingFilter(Session session) |
protected X11ForwardSupport |
AbstractConnectionService.createX11ForwardSupport(Session session) |
void |
ReservedSessionMessagesHandlerAdapter.handleDebugMessage(Session session,
boolean display,
String msg,
String lang,
Buffer buffer) |
void |
ReservedSessionMessagesHandlerAdapter.handleDebugMessage(Session session,
Buffer buffer) |
void |
ReservedSessionMessagesHandlerAdapter.handleIgnoreMessage(Session session,
Buffer buffer) |
void |
ReservedSessionMessagesHandlerAdapter.handleIgnoreMessage(Session session,
byte[] data,
Buffer buffer) |
boolean |
ReservedSessionMessagesHandlerAdapter.handleUnimplementedMessage(Session session,
int cmd,
Buffer buffer) |
IoWriteFuture |
ReservedSessionMessagesHandlerAdapter.sendIdentification(Session session,
String version,
List<String> extraLines) |
void |
SessionTimeoutListener.sessionClosed(Session s) |
void |
SessionTimeoutListener.sessionCreated(Session session) |
void |
SessionTimeoutListener.sessionException(Session session,
Throwable t) |
Constructor and Description |
---|
CurrentService(Session session)
Creates a new
CurrentService instance belonging to the given Session . |
Modifier and Type | Method and Description |
---|---|
InputStream |
DefaultScpStreamResolver.resolveSourceStream(Session session,
long length,
Set<PosixFilePermission> permissions,
OpenOption... options) |
Modifier and Type | Method and Description |
---|---|
Session |
ScpHelper.getSession() |
Modifier and Type | Method and Description |
---|---|
default void |
ScpFileOpener.closeRead(Session session,
Path file,
long size,
Set<PosixFilePermission> permissions,
InputStream stream)
Called when the stream obtained from
openRead is no
longer required since data has been successfully copied. |
default void |
ScpSourceStreamResolver.closeSourceStream(Session session,
long fileSize,
Set<PosixFilePermission> permissions,
InputStream stream)
Called when the stream obtained from
resolveSourceStream is no longer needed since since file copy was completed successfully. |
default void |
ScpTargetStreamResolver.closeTargetStream(Session session,
String name,
long length,
Set<PosixFilePermission> perms,
OutputStream stream)
Called when target stream received from
resolveTargetStream call is no longer needed since copy is successfully completed. |
default void |
ScpFileOpener.closeWrite(Session session,
Path file,
long size,
Set<PosixFilePermission> permissions,
OutputStream os)
Called when output stream obtained from
openWrite is
no longer needed since data copying has been successfully completed. |
ScpSourceStreamResolver |
ScpFileOpener.createScpSourceStreamResolver(Session session,
Path path) |
ScpTargetStreamResolver |
ScpFileOpener.createScpTargetStreamResolver(Session session,
Path path) |
void |
AbstractScpTransferEventListenerAdapter.endFileEvent(Session session,
ScpTransferEventListener.FileOperation op,
Path file,
long length,
Set<PosixFilePermission> perms,
Throwable thrown) |
default void |
ScpTransferEventListener.endFileEvent(Session session,
ScpTransferEventListener.FileOperation op,
Path file,
long length,
Set<PosixFilePermission> perms,
Throwable thrown) |
void |
AbstractScpTransferEventListenerAdapter.endFolderEvent(Session session,
ScpTransferEventListener.FileOperation op,
Path file,
Set<PosixFilePermission> perms,
Throwable thrown) |
default void |
ScpTransferEventListener.endFolderEvent(Session session,
ScpTransferEventListener.FileOperation op,
Path file,
Set<PosixFilePermission> perms,
Throwable thrown) |
default BasicFileAttributes |
ScpFileOpener.getLocalBasicFileAttributes(Session session,
Path path,
LinkOption... options) |
default Set<PosixFilePermission> |
ScpFileOpener.getLocalFilePermissions(Session session,
Path path,
LinkOption... options) |
default DirectoryStream<Path> |
ScpFileOpener.getLocalFolderChildren(Session session,
Path path)
Invoked when required to send all children of a local directory
|
default Iterable<Path> |
ScpFileOpener.getMatchingFilesToSend(Session session,
Path basedir,
String pattern)
Invoked when required to send a pattern of files
|
default void |
ScpTransferEventListener.handleFileEventAckInfo(Session session,
ScpTransferEventListener.FileOperation op,
Path file,
long length,
Set<PosixFilePermission> perms,
ScpAckInfo ackInfo)
Called after
ScpTransferEventListener.endFileEvent(Session, FileOperation, Path, long, Set, Throwable) if no exception was thrown
and the peer's ACK was successfully read |
InputStream |
ScpFileOpener.openRead(Session session,
Path file,
long size,
Set<PosixFilePermission> permissions,
OpenOption... options)
Create an input stream to read from a file
|
OutputStream |
ScpFileOpener.openWrite(Session session,
Path file,
long size,
Set<PosixFilePermission> permissions,
OpenOption... options)
Create an output stream to write to a file
|
void |
ScpReceiveLineHandler.process(Session session,
String line,
boolean isDir,
ScpTimestampCommandDetails time) |
default Path |
ScpFileOpener.resolveIncomingFilePath(Session session,
Path localPath,
String name,
boolean preserve,
Set<PosixFilePermission> permissions,
ScpTimestampCommandDetails time)
Invoked when receiving a new file to via a directory command
|
default Path |
ScpFileOpener.resolveIncomingReceiveLocation(Session session,
Path path,
boolean recursive,
boolean shouldBeDir,
boolean preserve)
Invoked when a request to receive something is processed
|
default Path |
ScpFileOpener.resolveLocalPath(Session session,
FileSystem fileSystem,
String commandPath) |
default Path |
ScpFileOpener.resolveOutgoingFilePath(Session session,
Path localPath,
LinkOption... options)
Called when there is a candidate file/folder for sending
|
InputStream |
ScpSourceStreamResolver.resolveSourceStream(Session session,
long fileSize,
Set<PosixFilePermission> permissions,
OpenOption... options) |
OutputStream |
ScpTargetStreamResolver.resolveTargetStream(Session session,
String name,
long length,
Set<PosixFilePermission> perms,
OpenOption... options)
Called when receiving a file in order to obtain an output stream for the incoming data
|
default boolean |
ScpFileOpener.sendAsDirectory(Session session,
Path path,
LinkOption... options)
Invoked on a local path in order to decide whether it should be sent as a file or as a directory
|
default boolean |
ScpFileOpener.sendAsRegularFile(Session session,
Path path,
LinkOption... options)
Invoked on a local path in order to decide whether it should be sent as a file or as a directory
|
void |
AbstractScpTransferEventListenerAdapter.startFileEvent(Session session,
ScpTransferEventListener.FileOperation op,
Path file,
long length,
Set<PosixFilePermission> perms) |
default void |
ScpTransferEventListener.startFileEvent(Session session,
ScpTransferEventListener.FileOperation op,
Path file,
long length,
Set<PosixFilePermission> perms) |
void |
AbstractScpTransferEventListenerAdapter.startFolderEvent(Session session,
ScpTransferEventListener.FileOperation op,
Path file,
Set<PosixFilePermission> perms) |
default void |
ScpTransferEventListener.startFolderEvent(Session session,
ScpTransferEventListener.FileOperation op,
Path file,
Set<PosixFilePermission> perms) |
protected void |
ScpHelper.validateFileOperationAckReplyCode(String command,
Session session,
ScpTransferEventListener.FileOperation op,
Path file,
long fileSize,
Set<PosixFilePermission> perms,
ScpAckInfo ackInfo) |
Constructor and Description |
---|
ScpHelper(Session session,
InputStream in,
Charset csIn,
OutputStream out,
Charset csOut,
FileSystem fileSystem,
ScpFileOpener opener,
ScpTransferEventListener eventListener) |
ScpHelper(Session session,
InputStream in,
OutputStream out,
FileSystem fileSystem,
ScpFileOpener opener,
ScpTransferEventListener eventListener) |
Modifier and Type | Method and Description |
---|---|
void |
LocalFileScpSourceStreamResolver.closeSourceStream(Session session,
long length,
Set<PosixFilePermission> permissions,
InputStream stream) |
void |
LocalFileScpTargetStreamResolver.closeTargetStream(Session session,
String name,
long length,
Set<PosixFilePermission> perms,
OutputStream stream) |
ScpSourceStreamResolver |
DefaultScpFileOpener.createScpSourceStreamResolver(Session session,
Path path) |
ScpTargetStreamResolver |
DefaultScpFileOpener.createScpTargetStreamResolver(Session session,
Path path) |
InputStream |
DefaultScpFileOpener.openRead(Session session,
Path file,
long size,
Set<PosixFilePermission> permissions,
OpenOption... options) |
OutputStream |
DefaultScpFileOpener.openWrite(Session session,
Path file,
long size,
Set<PosixFilePermission> permissions,
OpenOption... options) |
protected OpenOption[] |
DefaultScpFileOpener.resolveOpenOptions(Session session,
Path file,
long size,
Set<PosixFilePermission> permissions,
OpenOption... options) |
InputStream |
LocalFileScpSourceStreamResolver.resolveSourceStream(Session session,
long length,
Set<PosixFilePermission> permissions,
OpenOption... options) |
OutputStream |
LocalFileScpTargetStreamResolver.resolveTargetStream(Session session,
String name,
long length,
Set<PosixFilePermission> perms,
OpenOption... options) |
Modifier and Type | Method and Description |
---|---|
Channel |
ChannelSessionFactory.createChannel(Session session) |
static boolean |
PuttyRequestHandler.isPuttyClient(Session session) |
Modifier and Type | Method and Description |
---|---|
boolean |
TcpForwardingFilter.canConnect(TcpForwardingFilter.Type type,
SshdSocketAddress address,
Session session)
Determine if the session may create an outbound connection.
|
boolean |
StaticDecisionForwardingFilter.canConnect(TcpForwardingFilter.Type type,
SshdSocketAddress address,
Session session) |
boolean |
AgentForwardingFilter.canForwardAgent(Session session,
String requestType)
Determine if the session may arrange for agent forwarding.
|
boolean |
StaticDecisionForwardingFilter.canForwardAgent(Session session,
String requestType) |
boolean |
StaticDecisionForwardingFilter.canForwardX11(Session session,
String requestType) |
boolean |
X11ForwardingFilter.canForwardX11(Session session,
String requestType)
Determine if the session may arrange for X11 forwarding.
|
boolean |
TcpForwardingFilter.canListen(SshdSocketAddress address,
Session session)
Determine if the session may listen for inbound connections.
|
boolean |
StaticDecisionForwardingFilter.canListen(SshdSocketAddress address,
Session session) |
protected boolean |
StaticDecisionForwardingFilter.checkAcceptance(String request,
Session session,
SshdSocketAddress target) |
Channel |
TcpipServerChannel.TcpipFactory.createChannel(Session session) |
Modifier and Type | Method and Description |
---|---|
protected RequestHandler.Result |
OpenSshHostKeysHandler.handleHostKeys(Session session,
Collection<? extends PublicKey> keys,
boolean wantReply,
Buffer buffer) |
Constructor and Description |
---|
AbstractDHServerKeyExchange(Session s) |
DHGEXServer(DHFactory factory,
Session session) |
DHGServer(DHFactory factory,
Session session) |
Modifier and Type | Interface and Description |
---|---|
interface |
ServerSession |
Modifier and Type | Class and Description |
---|---|
class |
AbstractServerSession
Provides default implementations for
ServerSession related methods |
class |
ServerSessionImpl
The default implementation for a
ServerSession |
Modifier and Type | Method and Description |
---|---|
Service |
ServerConnectionServiceFactory.create(Session session) |
Service |
ServerUserAuthServiceFactory.create(Session session) |
Constructor and Description |
---|
ServerUserAuthService(Session s) |
Modifier and Type | Method and Description |
---|---|
protected ChannelAsyncOutputStream |
DefaultSftpClient.SftpChannelSubsystem.createAsyncInput(Session session) |
protected OutputStream |
DefaultSftpClient.SftpChannelSubsystem.createErrOutputStream(Session session) |
protected OutputStream |
DefaultSftpClient.SftpChannelSubsystem.createStdOutputStream(Session session) |
Copyright © 2008–2024 The Apache Software Foundation. All rights reserved.