/**
* @param charsetName The charset used to convert between Java Unicode Strings and byte encodings
*/
public void requestExecCommand(Channel c, String cmd, String charsetName) throws IOException {
PacketSessionExecCommand sm;
synchronized (c) {
if (c.state != Channel.STATE_OPEN)
throw new IOException(
"Cannot execute command on this channel (" + c.getReasonClosed() + ")");
sm = new PacketSessionExecCommand(c.remoteID, true, cmd);
c.successCounter = c.failedCounter = 0;
}
synchronized (c.channelSendLock) {
if (c.closeMessageSent)
throw new IOException(
"Cannot execute command on this channel (" + c.getReasonClosed() + ")");
tm.sendMessage(sm.getPayload(charsetName));
}
log.debug("Executing command (channel " + c.localID + ", '" + cmd + "')");
try {
waitForChannelSuccessOrFailure(c);
} catch (IOException e) {
throw (IOException) new IOException("The execute request failed.").initCause(e);
}
}
public void msgChannelClose(byte[] msg, int msglen) throws IOException {
if (msglen != 5)
throw new IOException("SSH_MSG_CHANNEL_CLOSE message has wrong size (" + msglen + ")");
int id =
((msg[1] & 0xff) << 24)
| ((msg[2] & 0xff) << 16)
| ((msg[3] & 0xff) << 8)
| (msg[4] & 0xff);
Channel c = getChannel(id);
if (c == null)
throw new IOException(
"Unexpected SSH_MSG_CHANNEL_CLOSE message for non-existent channel " + id);
synchronized (c) {
c.EOF = true;
c.state = Channel.STATE_CLOSED;
c.setReasonClosed("Close requested by remote");
c.closeMessageRecv = true;
removeChannel(c.localID);
c.notifyAll();
}
log.debug("Got SSH_MSG_CHANNEL_CLOSE (channel " + id + ")");
}
public void closeChannel(Channel c, String reason, boolean force) throws IOException {
byte msg[] = new byte[5];
synchronized (c) {
if (force) {
c.state = Channel.STATE_CLOSED;
c.EOF = true;
}
c.setReasonClosed(reason);
msg[0] = Packets.SSH_MSG_CHANNEL_CLOSE;
msg[1] = (byte) (c.remoteID >> 24);
msg[2] = (byte) (c.remoteID >> 16);
msg[3] = (byte) (c.remoteID >> 8);
msg[4] = (byte) (c.remoteID);
c.notifyAll();
}
synchronized (c.channelSendLock) {
if (c.closeMessageSent == true) return;
tm.sendMessage(msg);
c.closeMessageSent = true;
}
log.debug("Sent SSH_MSG_CHANNEL_CLOSE (channel " + c.localID + ")");
}
public void requestCancelGlobalForward(int bindPort) throws IOException {
RemoteForwardingData rfd = null;
synchronized (remoteForwardings) {
rfd = remoteForwardings.get(new Integer(bindPort));
if (rfd == null)
throw new IOException(
"Sorry, there is no known remote forwarding for remote port " + bindPort);
}
synchronized (channels) {
globalSuccessCounter = globalFailedCounter = 0;
}
PacketGlobalCancelForwardRequest pgcf =
new PacketGlobalCancelForwardRequest(true, rfd.bindAddress, rfd.bindPort);
tm.sendMessage(pgcf.getPayload());
log.debug(
"Requesting cancelation of remote forward ('"
+ rfd.bindAddress
+ "', "
+ rfd.bindPort
+ ")");
waitForGlobalSuccessOrFailure();
/* Only now we are sure that no more forwarded connections will arrive */
synchronized (remoteForwardings) {
remoteForwardings.remove(rfd);
}
}
public void msgChannelOpenConfirmation(byte[] msg, int msglen) throws IOException {
PacketChannelOpenConfirmation sm = new PacketChannelOpenConfirmation(msg, 0, msglen);
Channel c = getChannel(sm.recipientChannelID);
if (c == null)
throw new IOException(
"Unexpected SSH_MSG_CHANNEL_OPEN_CONFIRMATION message for non-existent channel "
+ sm.recipientChannelID);
synchronized (c) {
if (c.state != Channel.STATE_OPENING)
throw new IOException(
"Unexpected SSH_MSG_CHANNEL_OPEN_CONFIRMATION message for channel "
+ sm.recipientChannelID);
c.remoteID = sm.senderChannelID;
c.remoteWindow = sm.initialWindowSize & 0xFFFFffffL; /* convert UINT32 to long */
c.remoteMaxPacketSize = sm.maxPacketSize;
c.state = Channel.STATE_OPEN;
c.notifyAll();
}
log.debug(
"Got SSH_MSG_CHANNEL_OPEN_CONFIRMATION (channel "
+ sm.recipientChannelID
+ " / remote: "
+ sm.senderChannelID
+ ")");
}
public void unRegisterX11Cookie(String hexFakeCookie, boolean killChannels) {
if (hexFakeCookie == null) throw new IllegalStateException("hexFakeCookie may not be null");
synchronized (x11_magic_cookies) {
x11_magic_cookies.remove(hexFakeCookie);
}
if (killChannels == false) return;
log.debug("Closing all X11 channels for the given fake cookie");
List<Channel> channel_copy = new Vector<Channel>();
synchronized (channels) {
channel_copy.addAll(channels);
}
for (Channel c : channel_copy) {
synchronized (c) {
if (hexFakeCookie.equals(c.hexX11FakeCookie) == false) continue;
}
try {
closeChannel(c, "Closing X11 channel since the corresponding session is closing", true);
} catch (IOException ignored) {
}
}
}
public void msgGlobalFailure() throws IOException {
synchronized (channels) {
globalFailedCounter++;
channels.notifyAll();
}
log.debug("Got SSH_MSG_REQUEST_FAILURE");
}
public void msgGlobalSuccess() throws IOException {
synchronized (channels) {
globalSuccessCounter++;
channels.notifyAll();
}
log.debug("Got SSH_MSG_REQUEST_SUCCESS");
}
public void msgChannelData(byte[] msg, int msglen) throws IOException {
if (msglen <= 9)
throw new IOException("SSH_MSG_CHANNEL_DATA message has wrong size (" + msglen + ")");
int id =
((msg[1] & 0xff) << 24)
| ((msg[2] & 0xff) << 16)
| ((msg[3] & 0xff) << 8)
| (msg[4] & 0xff);
int len =
((msg[5] & 0xff) << 24)
| ((msg[6] & 0xff) << 16)
| ((msg[7] & 0xff) << 8)
| (msg[8] & 0xff);
Channel c = getChannel(id);
if (c == null)
throw new IOException(
"Unexpected SSH_MSG_CHANNEL_DATA message for non-existent channel " + id);
if (len != (msglen - 9))
throw new IOException(
"SSH_MSG_CHANNEL_DATA message has wrong len (calculated "
+ (msglen - 9)
+ ", got "
+ len
+ ")");
log.debug("Got SSH_MSG_CHANNEL_DATA (channel " + id + ", " + len + ")");
synchronized (c) {
if (c.state == Channel.STATE_CLOSED) return; // ignore
if (c.state != Channel.STATE_OPEN)
throw new IOException(
"Got SSH_MSG_CHANNEL_DATA, but channel is not in correct state (" + c.state + ")");
if (c.localWindow < len)
throw new IOException("Remote sent too much data, does not fit into window.");
c.localWindow -= len;
System.arraycopy(msg, 9, c.stdoutBuffer, c.stdoutWritepos, len);
c.stdoutWritepos += len;
c.notifyAll();
}
}
public void closeAllChannels() {
log.debug("Closing all channels");
List<Channel> channel_copy = new Vector<Channel>();
synchronized (channels) {
channel_copy.addAll(channels);
}
for (Channel c : channel_copy) {
try {
closeChannel(c, "Closing all channels", true);
} catch (IOException ignored) {
}
}
}
public Channel openSessionChannel() throws IOException {
Channel c = new Channel(this);
synchronized (c) {
c.localID = addChannel(c);
// end of synchronized block forces the writing out to main memory
}
log.debug("Sending SSH_MSG_CHANNEL_OPEN (Channel " + c.localID + ")");
PacketOpenSessionChannel smo =
new PacketOpenSessionChannel(c.localID, c.localWindow, c.localMaxPacketSize);
tm.sendMessage(smo.getPayload());
waitUntilChannelOpen(c);
return c;
}
public void sendEOF(Channel c) throws IOException {
byte[] msg = new byte[5];
synchronized (c) {
if (c.state != Channel.STATE_OPEN) return;
msg[0] = Packets.SSH_MSG_CHANNEL_EOF;
msg[1] = (byte) (c.remoteID >> 24);
msg[2] = (byte) (c.remoteID >> 16);
msg[3] = (byte) (c.remoteID >> 8);
msg[4] = (byte) (c.remoteID);
}
synchronized (c.channelSendLock) {
if (c.closeMessageSent == true) return;
tm.sendMessage(msg);
}
log.debug("Sent EOF (Channel " + c.localID + "/" + c.remoteID + ")");
}
public void msgGlobalRequest(byte[] msg, int msglen) throws IOException {
/* Currently we do not support any kind of global request */
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte(); // skip packet type
String requestName = tr.readString();
boolean wantReply = tr.readBoolean();
if (wantReply) {
byte[] reply_failure = new byte[1];
reply_failure[0] = Packets.SSH_MSG_REQUEST_FAILURE;
tm.sendAsynchronousMessage(reply_failure);
}
/* We do not clean up the requestName String - that is OK for debug */
log.debug("Got SSH_MSG_GLOBAL_REQUEST (" + requestName + ")");
}
public void requestX11(
Channel c,
boolean singleConnection,
String x11AuthenticationProtocol,
String x11AuthenticationCookie,
int x11ScreenNumber)
throws IOException {
PacketSessionX11Request psr;
synchronized (c) {
if (c.state != Channel.STATE_OPEN)
throw new IOException("Cannot request X11 on this channel (" + c.getReasonClosed() + ")");
psr =
new PacketSessionX11Request(
c.remoteID,
true,
singleConnection,
x11AuthenticationProtocol,
x11AuthenticationCookie,
x11ScreenNumber);
c.successCounter = c.failedCounter = 0;
}
synchronized (c.channelSendLock) {
if (c.closeMessageSent)
throw new IOException("Cannot request X11 on this channel (" + c.getReasonClosed() + ")");
tm.sendMessage(psr.getPayload());
}
log.debug("Requesting X11 forwarding (Channel " + c.localID + "/" + c.remoteID + ")");
try {
waitForChannelSuccessOrFailure(c);
} catch (IOException e) {
throw (IOException) new IOException("The X11 request failed.").initCause(e);
}
}
public int requestGlobalForward(
String bindAddress, int bindPort, String targetAddress, int targetPort) throws IOException {
RemoteForwardingData rfd = new RemoteForwardingData();
rfd.bindAddress = bindAddress;
rfd.bindPort = bindPort;
rfd.targetAddress = targetAddress;
rfd.targetPort = targetPort;
synchronized (remoteForwardings) {
Integer key = new Integer(bindPort);
if (remoteForwardings.get(key) != null) {
throw new IOException("There is already a forwarding for remote port " + bindPort);
}
remoteForwardings.put(key, rfd);
}
synchronized (channels) {
globalSuccessCounter = globalFailedCounter = 0;
}
PacketGlobalForwardRequest pgf = new PacketGlobalForwardRequest(true, bindAddress, bindPort);
tm.sendMessage(pgf.getPayload());
log.debug("Requesting a remote forwarding ('" + bindAddress + "', " + bindPort + ")");
try {
waitForGlobalSuccessOrFailure();
} catch (IOException e) {
synchronized (remoteForwardings) {
remoteForwardings.remove(rfd);
}
throw e;
}
return bindPort;
}
public void msgChannelFailure(byte[] msg, int msglen) throws IOException {
if (msglen != 5)
throw new IOException("SSH_MSG_CHANNEL_FAILURE message has wrong size (" + msglen + ")");
int id =
((msg[1] & 0xff) << 24)
| ((msg[2] & 0xff) << 16)
| ((msg[3] & 0xff) << 8)
| (msg[4] & 0xff);
Channel c = getChannel(id);
if (c == null)
throw new IOException(
"Unexpected SSH_MSG_CHANNEL_FAILURE message for non-existent channel " + id);
synchronized (c) {
c.failedCounter++;
c.notifyAll();
}
log.debug("Got SSH_MSG_CHANNEL_FAILURE (channel " + id + ")");
}
public void msgChannelWindowAdjust(byte[] msg, int msglen) throws IOException {
if (msglen != 9)
throw new IOException(
"SSH_MSG_CHANNEL_WINDOW_ADJUST message has wrong size (" + msglen + ")");
int id =
((msg[1] & 0xff) << 24)
| ((msg[2] & 0xff) << 16)
| ((msg[3] & 0xff) << 8)
| (msg[4] & 0xff);
int windowChange =
((msg[5] & 0xff) << 24)
| ((msg[6] & 0xff) << 16)
| ((msg[7] & 0xff) << 8)
| (msg[8] & 0xff);
Channel c = getChannel(id);
if (c == null)
throw new IOException(
"Unexpected SSH_MSG_CHANNEL_WINDOW_ADJUST message for non-existent channel " + id);
synchronized (c) {
final long huge = 0xFFFFffffL; /* 2^32 - 1 */
c.remoteWindow += (windowChange & huge); /* avoid sign extension */
/* TODO - is this a good heuristic? */
if ((c.remoteWindow > huge)) c.remoteWindow = huge;
c.notifyAll();
}
log.debug("Got SSH_MSG_CHANNEL_WINDOW_ADJUST (channel " + id + ", " + windowChange + ")");
}
public void msgChannelOpen(byte[] msg, int msglen) throws IOException {
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte(); // skip packet type
String channelType = tr.readString();
int remoteID = tr.readUINT32(); /* sender channel */
int remoteWindow = tr.readUINT32(); /* initial window size */
int remoteMaxPacketSize = tr.readUINT32(); /* maximum packet size */
if ("x11".equals(channelType)) {
synchronized (x11_magic_cookies) {
/* If we did not request X11 forwarding, then simply ignore this bogus request. */
if (x11_magic_cookies.size() == 0) {
PacketChannelOpenFailure pcof =
new PacketChannelOpenFailure(
remoteID,
Packets.SSH_OPEN_ADMINISTRATIVELY_PROHIBITED,
"X11 forwarding not activated",
"");
tm.sendAsynchronousMessage(pcof.getPayload());
log.warning("Unexpected X11 request, denying it!");
return;
}
}
String remoteOriginatorAddress = tr.readString();
int remoteOriginatorPort = tr.readUINT32();
Channel c = new Channel(this);
synchronized (c) {
c.remoteID = remoteID;
c.remoteWindow = remoteWindow & 0xFFFFffffL; /* properly convert UINT32 to long */
c.remoteMaxPacketSize = remoteMaxPacketSize;
c.localID = addChannel(c);
}
/*
* The open confirmation message will be sent from another thread
*/
RemoteX11AcceptThread rxat =
new RemoteX11AcceptThread(c, remoteOriginatorAddress, remoteOriginatorPort);
rxat.setDaemon(true);
rxat.start();
return;
}
if ("forwarded-tcpip".equals(channelType)) {
String remoteConnectedAddress = tr.readString(); /* address that was connected */
int remoteConnectedPort = tr.readUINT32(); /* port that was connected */
String remoteOriginatorAddress = tr.readString(); /* originator IP address */
int remoteOriginatorPort = tr.readUINT32(); /* originator port */
RemoteForwardingData rfd = null;
synchronized (remoteForwardings) {
rfd = remoteForwardings.get(new Integer(remoteConnectedPort));
}
if (rfd == null) {
PacketChannelOpenFailure pcof =
new PacketChannelOpenFailure(
remoteID,
Packets.SSH_OPEN_ADMINISTRATIVELY_PROHIBITED,
"No thanks, unknown port in forwarded-tcpip request",
"");
/* Always try to be polite. */
tm.sendAsynchronousMessage(pcof.getPayload());
log.debug("Unexpected forwarded-tcpip request, denying it!");
return;
}
Channel c = new Channel(this);
synchronized (c) {
c.remoteID = remoteID;
c.remoteWindow = remoteWindow & 0xFFFFffffL; /* convert UINT32 to long */
c.remoteMaxPacketSize = remoteMaxPacketSize;
c.localID = addChannel(c);
}
/*
* The open confirmation message will be sent from another thread.
*/
RemoteAcceptThread rat =
new RemoteAcceptThread(
c,
remoteConnectedAddress,
remoteConnectedPort,
remoteOriginatorAddress,
remoteOriginatorPort,
rfd.targetAddress,
rfd.targetPort);
rat.setDaemon(true);
rat.start();
return;
}
if ((server_state != null) && ("session".equals(channelType))) {
ServerConnectionCallback cb = null;
synchronized (server_state) {
cb = server_state.cb_conn;
}
if (cb == null) {
tm.sendAsynchronousMessage(
new PacketChannelOpenFailure(
remoteID,
Packets.SSH_OPEN_ADMINISTRATIVELY_PROHIBITED,
"Sessions are currently not enabled",
"en")
.getPayload());
return;
}
final Channel c = new Channel(this);
synchronized (c) {
c.remoteID = remoteID;
c.remoteWindow = remoteWindow & 0xFFFFffffL; /* convert UINT32 to long */
c.remoteMaxPacketSize = remoteMaxPacketSize;
c.localID = addChannel(c);
c.state = Channel.STATE_OPEN;
c.ss = new ServerSessionImpl(c);
}
PacketChannelOpenConfirmation pcoc =
new PacketChannelOpenConfirmation(
c.remoteID, c.localID, c.localWindow, c.localMaxPacketSize);
tm.sendAsynchronousMessage(pcoc.getPayload());
c.ss.sscb = cb.acceptSession(c.ss);
return;
}
/* Tell the server that we have no idea what it is talking about */
PacketChannelOpenFailure pcof =
new PacketChannelOpenFailure(
remoteID, Packets.SSH_OPEN_UNKNOWN_CHANNEL_TYPE, "Unknown channel type", "");
tm.sendAsynchronousMessage(pcof.getPayload());
log.warning("The peer tried to open an unsupported channel type (" + channelType + ")");
}
public void msgChannelRequest(byte[] msg, int msglen) throws IOException {
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte(); // skip packet type
int id = tr.readUINT32();
Channel c = getChannel(id);
if (c == null)
throw new IOException(
"Unexpected SSH_MSG_CHANNEL_REQUEST message for non-existent channel " + id);
ServerSessionImpl server_session = null;
if (server_state != null) {
synchronized (c) {
server_session = c.ss;
}
}
String type = tr.readString("US-ASCII");
boolean wantReply = tr.readBoolean();
log.debug("Got SSH_MSG_CHANNEL_REQUEST (channel " + id + ", '" + type + "')");
if (type.equals("exit-status")) {
if (wantReply != false)
throw new IOException(
"Badly formatted SSH_MSG_CHANNEL_REQUEST exit-status message, 'want reply' is true");
int exit_status = tr.readUINT32();
if (tr.remain() != 0)
throw new IOException("Badly formatted SSH_MSG_CHANNEL_REQUEST message");
synchronized (c) {
c.exit_status = new Integer(exit_status);
c.notifyAll();
}
log.debug("Got EXIT STATUS (channel " + id + ", status " + exit_status + ")");
return;
}
if ((server_state == null) && (type.equals("exit-signal"))) {
if (wantReply != false)
throw new IOException(
"Badly formatted SSH_MSG_CHANNEL_REQUEST exit-signal message, 'want reply' is true");
String signame = tr.readString("US-ASCII");
tr.readBoolean();
tr.readString();
tr.readString();
if (tr.remain() != 0)
throw new IOException("Badly formatted SSH_MSG_CHANNEL_REQUEST message");
synchronized (c) {
c.exit_signal = signame;
c.notifyAll();
}
log.debug("Got EXIT SIGNAL (channel " + id + ", signal " + signame + ")");
return;
}
if ((server_session != null) && (type.equals("pty-req"))) {
PtySettings pty = new PtySettings();
pty.term = tr.readString();
pty.term_width_characters = tr.readUINT32();
pty.term_height_characters = tr.readUINT32();
pty.term_width_pixels = tr.readUINT32();
pty.term_height_pixels = tr.readUINT32();
pty.terminal_modes = tr.readByteString();
if (tr.remain() != 0)
throw new IOException("Badly formatted SSH_MSG_CHANNEL_REQUEST message");
Runnable run_after_sending_success = null;
ServerSessionCallback sscb = server_session.getServerSessionCallback();
if (sscb != null) run_after_sending_success = sscb.requestPtyReq(server_session, pty);
if (wantReply) {
if (run_after_sending_success != null) {
tm.sendAsynchronousMessage(new PacketChannelSuccess(c.remoteID).getPayload());
} else {
tm.sendAsynchronousMessage(new PacketChannelFailure(c.remoteID).getPayload());
}
}
if (run_after_sending_success != null) {
runAsync(run_after_sending_success);
}
return;
}
if ((server_session != null) && (type.equals("shell"))) {
if (tr.remain() != 0)
throw new IOException("Badly formatted SSH_MSG_CHANNEL_REQUEST message");
Runnable run_after_sending_success = null;
ServerSessionCallback sscb = server_session.getServerSessionCallback();
if (sscb != null) run_after_sending_success = sscb.requestShell(server_session);
if (wantReply) {
if (run_after_sending_success != null) {
tm.sendAsynchronousMessage(new PacketChannelSuccess(c.remoteID).getPayload());
} else {
tm.sendAsynchronousMessage(new PacketChannelFailure(c.remoteID).getPayload());
}
}
if (run_after_sending_success != null) {
runAsync(run_after_sending_success);
}
return;
}
if ((server_session != null) && (type.equals("exec"))) {
String command = tr.readString();
if (tr.remain() != 0)
throw new IOException("Badly formatted SSH_MSG_CHANNEL_REQUEST message");
Runnable run_after_sending_success = null;
ServerSessionCallback sscb = server_session.getServerSessionCallback();
if (sscb != null) run_after_sending_success = sscb.requestExec(server_session, command);
if (wantReply) {
if (run_after_sending_success != null) {
tm.sendAsynchronousMessage(new PacketChannelSuccess(c.remoteID).getPayload());
} else {
tm.sendAsynchronousMessage(new PacketChannelFailure(c.remoteID).getPayload());
}
}
if (run_after_sending_success != null) {
runAsync(run_after_sending_success);
}
return;
}
/* We simply ignore unknown channel requests, however, if the server wants a reply,
* then we signal that we have no idea what it is about.
*/
if (wantReply) {
tm.sendAsynchronousMessage(new PacketChannelFailure(c.remoteID).getPayload());
}
log.debug("Channel request '" + type + "' is not known, ignoring it");
}
public void msgChannelOpenFailure(byte[] msg, int msglen) throws IOException {
if (msglen < 5)
throw new IOException("SSH_MSG_CHANNEL_OPEN_FAILURE message has wrong size (" + msglen + ")");
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte(); // skip packet type
int id = tr.readUINT32(); /* sender channel */
Channel c = getChannel(id);
if (c == null)
throw new IOException(
"Unexpected SSH_MSG_CHANNEL_OPEN_FAILURE message for non-existent channel " + id);
int reasonCode = tr.readUINT32();
String description = tr.readString("UTF-8");
String reasonCodeSymbolicName = null;
switch (reasonCode) {
case 1:
reasonCodeSymbolicName = "SSH_OPEN_ADMINISTRATIVELY_PROHIBITED";
break;
case 2:
reasonCodeSymbolicName = "SSH_OPEN_CONNECT_FAILED";
break;
case 3:
reasonCodeSymbolicName = "SSH_OPEN_UNKNOWN_CHANNEL_TYPE";
break;
case 4:
reasonCodeSymbolicName = "SSH_OPEN_RESOURCE_SHORTAGE";
break;
default:
reasonCodeSymbolicName = "UNKNOWN REASON CODE (" + reasonCode + ")";
}
StringBuilder descriptionBuffer = new StringBuilder();
descriptionBuffer.append(description);
for (int i = 0; i < descriptionBuffer.length(); i++) {
char cc = descriptionBuffer.charAt(i);
if ((cc >= 32) && (cc <= 126)) continue;
descriptionBuffer.setCharAt(i, '\uFFFD');
}
synchronized (c) {
c.EOF = true;
c.state = Channel.STATE_CLOSED;
c.setReasonClosed(
"The server refused to open the channel ("
+ reasonCodeSymbolicName
+ ", '"
+ descriptionBuffer.toString()
+ "')");
c.notifyAll();
}
log.debug("Got SSH_MSG_CHANNEL_OPEN_FAILURE (channel " + id + ")");
}
public int getChannelData(Channel c, boolean extended, byte[] target, int off, int len)
throws IOException {
boolean wasInterrupted = false;
try {
int copylen = 0;
int increment = 0;
int remoteID = 0;
int localID = 0;
synchronized (c) {
int stdoutAvail = 0;
int stderrAvail = 0;
while (true) {
/*
* Data available? We have to return remaining data even if the
* channel is already closed.
*/
stdoutAvail = c.stdoutWritepos - c.stdoutReadpos;
stderrAvail = c.stderrWritepos - c.stderrReadpos;
if ((!extended) && (stdoutAvail != 0)) break;
if ((extended) && (stderrAvail != 0)) break;
/* Do not wait if more data will never arrive (EOF or CLOSED) */
if ((c.EOF) || (c.state != Channel.STATE_OPEN)) return -1;
try {
c.wait();
} catch (InterruptedException ignore) {
wasInterrupted = true;
}
}
/* OK, there is some data. Return it. */
if (!extended) {
copylen = (stdoutAvail > len) ? len : stdoutAvail;
System.arraycopy(c.stdoutBuffer, c.stdoutReadpos, target, off, copylen);
c.stdoutReadpos += copylen;
if (c.stdoutReadpos != c.stdoutWritepos)
System.arraycopy(
c.stdoutBuffer,
c.stdoutReadpos,
c.stdoutBuffer,
0,
c.stdoutWritepos - c.stdoutReadpos);
c.stdoutWritepos -= c.stdoutReadpos;
c.stdoutReadpos = 0;
} else {
copylen = (stderrAvail > len) ? len : stderrAvail;
System.arraycopy(c.stderrBuffer, c.stderrReadpos, target, off, copylen);
c.stderrReadpos += copylen;
if (c.stderrReadpos != c.stderrWritepos)
System.arraycopy(
c.stderrBuffer,
c.stderrReadpos,
c.stderrBuffer,
0,
c.stderrWritepos - c.stderrReadpos);
c.stderrWritepos -= c.stderrReadpos;
c.stderrReadpos = 0;
}
if (c.state != Channel.STATE_OPEN) return copylen;
if (c.localWindow < ((Channel.CHANNEL_BUFFER_SIZE + 1) / 2)) {
int minFreeSpace =
Math.min(
Channel.CHANNEL_BUFFER_SIZE - c.stdoutWritepos,
Channel.CHANNEL_BUFFER_SIZE - c.stderrWritepos);
increment = minFreeSpace - c.localWindow;
c.localWindow = minFreeSpace;
}
remoteID = c.remoteID; /* read while holding the lock */
localID = c.localID; /* read while holding the lock */
}
/*
* If a consumer reads stdout and stdin in parallel, we may end up with
* sending two msgWindowAdjust messages. Luckily, it
* does not matter in which order they arrive at the server.
*/
if (increment > 0) {
log.debug(
"Sending SSH_MSG_CHANNEL_WINDOW_ADJUST (channel " + localID + ", " + increment + ")");
synchronized (c.channelSendLock) {
byte[] msg = c.msgWindowAdjust;
msg[0] = Packets.SSH_MSG_CHANNEL_WINDOW_ADJUST;
msg[1] = (byte) (remoteID >> 24);
msg[2] = (byte) (remoteID >> 16);
msg[3] = (byte) (remoteID >> 8);
msg[4] = (byte) (remoteID);
msg[5] = (byte) (increment >> 24);
msg[6] = (byte) (increment >> 16);
msg[7] = (byte) (increment >> 8);
msg[8] = (byte) (increment);
if (c.closeMessageSent == false) tm.sendMessage(msg);
}
}
return copylen;
} finally {
if (wasInterrupted) Thread.currentThread().interrupt();
}
}
public void handleMessage(byte[] msg, int msglen) throws IOException {
if (msg == null) {
log.debug("HandleMessage: got shutdown");
synchronized (listenerThreads) {
for (IChannelWorkerThread lat : listenerThreads) {
lat.stopWorking();
}
listenerThreadsAllowed = false;
}
synchronized (channels) {
shutdown = true;
for (Channel c : channels) {
synchronized (c) {
c.EOF = true;
c.state = Channel.STATE_CLOSED;
c.setReasonClosed("The connection is being shutdown");
c.closeMessageRecv = true; /*
* You never know, perhaps
* we are waiting for a
* pending close message
* from the server...
*/
c.notifyAll();
}
}
channels.clear();
channels.notifyAll(); /* Notify global response waiters */
return;
}
}
switch (msg[0]) {
case Packets.SSH_MSG_CHANNEL_OPEN_CONFIRMATION:
msgChannelOpenConfirmation(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_WINDOW_ADJUST:
msgChannelWindowAdjust(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_DATA:
msgChannelData(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_EXTENDED_DATA:
msgChannelExtendedData(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_REQUEST:
msgChannelRequest(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_EOF:
msgChannelEOF(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_OPEN:
msgChannelOpen(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_CLOSE:
msgChannelClose(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_SUCCESS:
msgChannelSuccess(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_FAILURE:
msgChannelFailure(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_OPEN_FAILURE:
msgChannelOpenFailure(msg, msglen);
break;
case Packets.SSH_MSG_GLOBAL_REQUEST:
msgGlobalRequest(msg, msglen);
break;
case Packets.SSH_MSG_REQUEST_SUCCESS:
msgGlobalSuccess();
break;
case Packets.SSH_MSG_REQUEST_FAILURE:
msgGlobalFailure();
break;
default:
throw new IOException("Cannot handle unknown channel message " + (msg[0] & 0xff));
}
}
public void receiveLoop() throws IOException {
byte[] msg = new byte[35000];
while (true) {
int msglen;
try {
msglen = tc.receiveMessage(msg, 0, msg.length);
} catch (SocketTimeoutException e) {
// Timeout in read
if (idle) {
log.debug("Ignoring socket timeout");
continue;
}
throw e;
}
idle = true;
int type = msg[0] & 0xff;
if (type == Packets.SSH_MSG_IGNORE) {
continue;
}
if (type == Packets.SSH_MSG_DEBUG) {
if (log.isDebugEnabled()) {
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte();
tr.readBoolean();
StringBuilder debugMessageBuffer = new StringBuilder();
debugMessageBuffer.append(tr.readString("UTF-8"));
for (int i = 0; i < debugMessageBuffer.length(); i++) {
char c = debugMessageBuffer.charAt(i);
if ((c >= 32) && (c <= 126)) {
continue;
}
debugMessageBuffer.setCharAt(i, '\uFFFD');
}
log.debug("DEBUG Message from remote: '" + debugMessageBuffer.toString() + "'");
}
continue;
}
if (type == Packets.SSH_MSG_UNIMPLEMENTED) {
throw new IOException("Peer sent UNIMPLEMENTED message, that should not happen.");
}
if (type == Packets.SSH_MSG_DISCONNECT) {
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte();
int reason_code = tr.readUINT32();
StringBuilder reasonBuffer = new StringBuilder();
reasonBuffer.append(tr.readString("UTF-8"));
/*
* Do not get fooled by servers that send abnormal long error
* messages
*/
if (reasonBuffer.length() > 255) {
reasonBuffer.setLength(255);
reasonBuffer.setCharAt(254, '.');
reasonBuffer.setCharAt(253, '.');
reasonBuffer.setCharAt(252, '.');
}
/*
* Also, check that the server did not send characters that may
* screw up the receiver -> restrict to reasonable US-ASCII
* subset -> "printable characters" (ASCII 32 - 126). Replace
* all others with 0xFFFD (UNICODE replacement character).
*/
for (int i = 0; i < reasonBuffer.length(); i++) {
char c = reasonBuffer.charAt(i);
if ((c >= 32) && (c <= 126)) {
continue;
}
reasonBuffer.setCharAt(i, '\uFFFD');
}
throw new IOException(
"Peer sent DISCONNECT message (reason code "
+ reason_code
+ "): "
+ reasonBuffer.toString());
}
/*
* Is it a KEX Packet?
*/
if ((type == Packets.SSH_MSG_KEXINIT)
|| (type == Packets.SSH_MSG_NEWKEYS)
|| ((type >= 30) && (type <= 49))) {
km.handleMessage(msg, msglen);
continue;
}
MessageHandler mh = null;
for (int i = 0; i < messageHandlers.size(); i++) {
HandlerEntry he = messageHandlers.get(i);
if ((he.low <= type) && (type <= he.high)) {
mh = he.mh;
break;
}
}
if (mh == null) {
throw new IOException("Unexpected SSH message (type " + type + ")");
}
mh.handleMessage(msg, msglen);
}
}
public void msgChannelRequest(byte[] msg, int msglen) throws IOException {
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte(); // skip packet type
int id = tr.readUINT32();
Channel c = getChannel(id);
if (c == null)
throw new IOException(
"Unexpected SSH_MSG_CHANNEL_REQUEST message for non-existent channel " + id);
String type = tr.readString("US-ASCII");
boolean wantReply = tr.readBoolean();
log.debug("Got SSH_MSG_CHANNEL_REQUEST (channel " + id + ", '" + type + "')");
if (type.equals("exit-status")) {
if (wantReply != false)
throw new IOException(
"Badly formatted SSH_MSG_CHANNEL_REQUEST message, 'want reply' is true");
int exit_status = tr.readUINT32();
if (tr.remain() != 0)
throw new IOException("Badly formatted SSH_MSG_CHANNEL_REQUEST message");
synchronized (c) {
c.exit_status = new Integer(exit_status);
c.notifyAll();
}
log.debug("Got EXIT STATUS (channel " + id + ", status " + exit_status + ")");
return;
}
if (type.equals("exit-signal")) {
if (wantReply != false)
throw new IOException(
"Badly formatted SSH_MSG_CHANNEL_REQUEST message, 'want reply' is true");
String signame = tr.readString("US-ASCII");
tr.readBoolean();
tr.readString();
tr.readString();
if (tr.remain() != 0)
throw new IOException("Badly formatted SSH_MSG_CHANNEL_REQUEST message");
synchronized (c) {
c.exit_signal = signame;
c.notifyAll();
}
log.debug("Got EXIT SIGNAL (channel " + id + ", signal " + signame + ")");
return;
}
/* We simply ignore unknown channel requests, however, if the server wants a reply,
* then we signal that we have no idea what it is about.
*/
if (wantReply) {
byte[] reply = new byte[5];
reply[0] = Packets.SSH_MSG_CHANNEL_FAILURE;
reply[1] = (byte) (c.remoteID >> 24);
reply[2] = (byte) (c.remoteID >> 16);
reply[3] = (byte) (c.remoteID >> 8);
reply[4] = (byte) (c.remoteID);
tm.sendAsynchronousMessage(reply);
}
log.debug("Channel request '" + type + "' is not known, ignoring it");
}
