org.apache.sshd.server.channel.ChannelSession Java Examples

@Test
void name() {
    SshShellListenerService service = new SshShellListenerService(Arrays.asList(
            event -> {
                assertNotNull(event);
                assertNotNull(event.toString());
                assertNotNull(event.getType());
                assertNotNull(event.getSession());
                assertEquals(123L, event.getSessionId());
            }, event -> {
                throw new IllegalArgumentException("[TEST]");
            }
    ));

    ChannelSession session = mockChannelSession(123L);

    service.onSessionStarted(session);
    service.onSessionStopped(session);
    service.onSessionError(session);

    // no exception during executions event with illegal argument exception -> only error log
}
 

@ShellMethod("Displays active sessions")
public String manageSessionsList() {
    Map<Long, ChannelSession> sessions = sessionManager.listSessions();

    SimpleTable.SimpleTableBuilder builder = SimpleTable.builder()
            .column("Session Id").column("Local address").column("Remote address").column("Authenticated User");

    for (ChannelSession value : sessions.values()) {
        builder.line(Arrays.asList(
                value.getServerSession().getIoSession().getId(),
                value.getServerSession().getIoSession().getLocalAddress(),
                value.getServerSession().getIoSession().getRemoteAddress(),
                sessionUserName(value)
        ));
    }
    return helper.renderTable(builder.build());
}
 

public SshShellRunnable(SshShellProperties properties, ChannelSession session,
                        SshShellListenerService shellListenerService, Banner shellBanner,
                        PromptProvider promptProvider, Shell shell,
                        JLineShellAutoConfiguration.CompleterAdapter completerAdapter, Parser parser,
                        Environment environment, org.apache.sshd.server.Environment sshEnv,
                        SshShellCommandFactory sshShellCommandFactory, InputStream is,
                        OutputStream os, ExitCallback ec) {
    this.properties = properties;
    this.session = session;
    this.shellListenerService = shellListenerService;
    this.shellBanner = shellBanner;
    this.promptProvider = promptProvider;
    this.shell = shell;
    this.completerAdapter = completerAdapter;
    this.parser = parser;
    this.environment = environment;
    this.sshEnv = sshEnv;
    this.sshShellCommandFactory = sshShellCommandFactory;
    this.is = is;
    this.os = os;
    this.ec = ec;
}
 

@Override
public int data(final ChannelSession channel, byte[] buf, int start, int len) throws IOException {
    buffer.append(new String(buf, start, len));
    for (int i = 0; i < buffer.length(); i++) {
        if (buffer.charAt(i) == '\n') {
            final String s = buffer.substring(0, i + 1);
            final byte[] bytes = s.getBytes(StandardCharsets.UTF_8);
            out.write(new ByteArrayBuffer(bytes)).addListener(new SshFutureListener<IoWriteFuture>() {
                @Override
                public void operationComplete(IoWriteFuture future) {
                    Session session = channel.getSession();
                    if (future.isWritten()) {
                        try {
                            Window wLocal = channel.getLocalWindow();
                            wLocal.consumeAndCheck(bytes.length);
                        } catch (IOException e) {
                            session.exceptionCaught(e);
                        }
                    } else {
                        Throwable t = future.getException();
                        session.exceptionCaught(t);
                    }
                }
            });
            buffer = new StringBuilder(buffer.substring(i + 1));
            i = 0;
        }
    }
    return 0;
}
 

@Override
public int data(ChannelSession channel, byte[] buf, int start, int len) throws IOException {
    if (decoder != null) {
        lastAccessedTime = System.currentTimeMillis();
        decoder.write(buf, start, len);
    } else {
        // Data send too early ?
    }
    return len;
}
 

@Override
public void start(ChannelSession channel, Environment env) throws IOException {
    terminalType = env.getEnv().get(Environment.ENV_TERM);
    this.channel = channel;
    sshThread = new Thread(this, "ssh-cli " + channel.getSession().getIoSession().getAttribute(Constants.USER));
    sshThread.start();
}
 

public static ChannelSession mockChannelSession(Long id) {
    ChannelSession session = mock(ChannelSession.class);
    ServerSession serverSession = mock(ServerSession.class);
    when(session.getSession()).thenReturn(serverSession);
    IoSession ioSession = mock(IoSession.class);
    when(serverSession.getIoSession()).thenReturn(ioSession);
    when(ioSession.getId()).thenReturn(id);
    return session;
}
 

@Override
public int data(ChannelSession channel, byte[] buf, int start, int len) throws IOException {
  if (decoder != null) {
    lastAccessedTime = System.currentTimeMillis();
    decoder.write(buf, start, len);
  } else {
    // Data send too early ?
  }
  return len;
}
 

/**
 * Search for authenticated user in session
 *
 * @param session ssh session
 * @return user name
 */
public static String sessionUserName(ChannelSession session) {
    SshAuthentication authentication =
            (SshAuthentication) session.getServerSession().getIoSession().getAttribute("authentication");
    if (authentication == null) {
        return null;
    }
    return authentication.getName();
}
 

/**
 * Stop active session
 *
 * @param id session id
 * @return true if session found and stopped, false otherwise
 */
public boolean stopSession(long id) {
    ChannelSession session = getSession(id);
    if (session != null) {
        this.commandFactory.destroy(session);
        return true;
    }
    return false;
}
 

@Override
public void start(final ChannelSession channel, final Environment env) throws IOException {
	if (err != null) {
		err.write("shell not allowed\r\n".getBytes("ISO-8859-1"));
		err.flush();
	}
	if (callback != null)
		callback.onExit(-1, "shell not allowed");
}
 

@Override
public void destroy(ChannelSession channelSession) {
    Thread sshThread = threads.remove(channelSession);
    if (sshThread != null) {
        sshThread.interrupt();
    }
    LOGGER.debug("{}: destroyed [{} session(s) currently active]", channelSession, threads.size());
}
 

/**
 * Start ssh session
 *
 * @param channelSession ssh channel session
 * @param env            ssh environment
 */
@Override
public void start(ChannelSession channelSession, org.apache.sshd.server.Environment env) {
    SshIO sshIO = SSH_IO_CONTEXT.get();
    Thread sshThread = new Thread(new ThreadGroup("ssh-shell"), new SshShellRunnable(properties,
            channelSession, shellListenerService, shellBanner, promptProvider, shell, completerAdapter, parser,
            environment, env, this, sshIO.getIs(), sshIO.getOs(), sshIO.getEc()),
            "ssh-session-" + System.nanoTime());
    sshThread.start();
    threads.put(channelSession, sshThread);
    LOGGER.debug("{}: started [{} session(s) currently active]", channelSession, threads.size());
}
 

@ShellMethod("Displays session")
public String manageSessionsInfo(@ShellOption(value = {"-i", "--session-id"}) long sessionId) {
    ChannelSession session = sessionManager.getSession(sessionId);
    if (session == null) {
        return helper.getError("Session [" + sessionId + "] not found");
    }
    return helper.getSuccess(sessionTable(session.getServerSession()));
}
 

@Override
public int data(final ChannelSession channel, byte[] buf, int start, int len) throws IOException {
    buffer.append(new String(buf, start, len));
    for (int i = 0; i < buffer.length(); i++) {
        if (buffer.charAt(i) == '\n') {
            final String s = buffer.substring(0, i + 1);
            final byte[] bytes = s.getBytes(StandardCharsets.UTF_8);
            out.write(new ByteArrayBuffer(bytes)).addListener(new SshFutureListener<IoWriteFuture>() {
                @Override
                public void operationComplete(IoWriteFuture future) {
                    Session session = channel.getSession();
                    if (future.isWritten()) {
                        try {
                            Window wLocal = channel.getLocalWindow();
                            wLocal.consumeAndCheck(bytes.length);
                        } catch (IOException e) {
                            session.exceptionCaught(e);
                        }
                    } else {
                        Throwable t = future.getException();
                        session.exceptionCaught(t);
                    }
                }
            });
            buffer = new StringBuilder(buffer.substring(i + 1));
            i = 0;
        }
    }
    return 0;
}
 

@Override
public int data(ChannelSession channel, byte[] buf, int start, int len) throws IOException {
  if (decoder != null) {
    lastAccessedTime = System.currentTimeMillis();
    decoder.write(buf, start, len);
  } else {
    // Data send too early ?
  }
  return len;
}
 

@Override
public Command createShell(final ChannelSession channel) throws IOException {
	return new SecureShellCommand();
}
 

@Override
public void setChannelSession(ChannelSession session) {
  this.session = session;
}
 

@Override
public void setChannelSession(ChannelSession session) {
    this.session = session;
}
 

@Override
public void setChannelSession(ChannelSession session) {
  this.session = session;
}
 

@Override
public void setChannelSession(ChannelSession session) {
    this.session = session;
}
 

@Override
public void destroy(final ChannelSession channel) {
}
 

@Override
public void destroy(ChannelSession channel) throws Exception {
    channel.close();
    sshThread.interrupt();
}
 

@Override
public void setChannelSession(ChannelSession session) {
    this.session = session;
}
 

public Map<Long, ChannelSession> listSessions() {
    return threads.keySet().stream()
            .collect(Collectors.toMap(s -> s.getServerSession().getIoSession().getId(), Function.identity()));
}
 

@Override
public void setChannelSession(ChannelSession session) {
    this.session = session;
}
 

/**
 * Session stopped with error
 *
 * @param channelSession ssh channel session
 */
public void onSessionError(ChannelSession channelSession) {
    notify(new SshShellEvent(SshShellEventType.SESSION_STOPPED_UNEXPECTEDLY, channelSession));
}
 

/**
 * Session stopped
 *
 * @param channelSession ssh channel session
 */
public void onSessionStopped(ChannelSession channelSession) {
    notify(new SshShellEvent(SshShellEventType.SESSION_STOPPED, channelSession));
}
 

/**
 * Session started
 *
 * @param channelSession ssh channel session
 */
public void onSessionStarted(ChannelSession channelSession) {
    notify(new SshShellEvent(SshShellEventType.SESSION_STARTED, channelSession));
}
 

/**
 * @param id session id
 * @return found session, or null if not existing
 */
public ChannelSession getSession(long id) {
    return listSessions().get(id);
}