| /** |
| * Copyright (C) 2010 Cloud.com, Inc. All rights reserved. |
| * |
| * This software is licensed under the GNU General Public License v3 or later. |
| * |
| * It is free software: you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation, either version 3 of the License, or any later version. |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program. If not, see <http://www.gnu.org/licenses/>. |
| * |
| */ |
| |
| package com.cloud.consoleproxy;
|
|
|
| import java.io.BufferedInputStream;
|
| import java.io.DataInputStream;
|
| import java.io.IOException;
|
| import java.io.OutputStream;
|
| import java.net.Socket;
|
| import java.util.StringTokenizer;
|
|
|
| import com.cloud.console.Logger; |
| import com.cloud.console.RfbProto; |
|
|
| public class ConsoleProxyClientHandler extends Thread {
|
| private static final Logger s_logger = Logger.getLogger(ConsoleProxyClientHandler.class);
|
|
|
| Socket clientSocket = null;
|
| DataInputStream clientIns = null;
|
| OutputStream clientOuts = null;
|
|
|
| public ConsoleProxyClientHandler(Socket client) {
|
| clientSocket = client;
|
| }
|
|
|
| synchronized void cleanup() {
|
| try {
|
| if (clientSocket != null) {
|
| s_logger.info("Closing connection to "
|
| + clientSocket.getInetAddress());
|
|
|
| clientSocket.close();
|
| clientSocket = null;
|
| }
|
| } catch (IOException ioe) {
|
| }
|
| try {
|
| if (clientIns != null) {
|
| clientIns.close();
|
| clientIns = null;
|
| }
|
| } catch (IOException ioe) {
|
| }
|
| try {
|
| if (clientOuts != null) {
|
| clientOuts.close();
|
| clientOuts = null;
|
| }
|
| } catch (IOException ioe) {
|
| }
|
| }
|
|
|
| public void run() {
|
| try {
|
| String srcinfo = clientSocket.getInetAddress().getHostAddress() +
|
| ":" + clientSocket.getPort();
|
| clientIns = new DataInputStream(new BufferedInputStream(
|
| clientSocket.getInputStream()));
|
| // clientOuts = new GZIPOutputStream(clientSocket.getOutputStream(), 65536);
|
| clientOuts = clientSocket.getOutputStream();
|
| clientOuts.write("RFB 000.000\000".getBytes("US-ASCII"));
|
| clientOuts.flush();
|
| int b1 = clientIns.read();
|
| int b2 = clientIns.read();
|
| if (b1 != 'V' || b2 != 'M') {
|
| throw new Exception ("Bad header");
|
| }
|
| byte[] proxyInfo = new byte[clientIns.read()];
|
| clientIns.readFully(proxyInfo);
|
| String proxyString = new String(proxyInfo, "US-ASCII");
|
| StringTokenizer stk = new StringTokenizer(proxyString, ":\n");
|
| String host = stk.nextToken();
|
| int port = Integer.parseInt(stk.nextToken());
|
| String sid = stk.nextToken();
|
| ConsoleProxyViewer viewer = ConsoleProxy.getVncViewer(host, port, sid, "", "");
|
|
|
| ConsoleProxy.waitForViewerToStart(viewer);
|
|
|
| handleClientSession(viewer, srcinfo);
|
| } catch (Exception ioe) {
|
| if(s_logger.isDebugEnabled())
|
| s_logger.debug(ioe.toString());
|
| } finally {
|
| cleanup();
|
| }
|
| }
|
|
|
| void writeServer (ConsoleProxyViewer viewer, byte[] b, int off, int len) {
|
| viewer.writeServer(b, off, len);
|
| }
|
|
|
| void writeClientU16 (int n) throws IOException {
|
| byte[] b = new byte[2];
|
| b[0] = (byte) ((n >> 8) & 0xff);
|
| b[1] = (byte) (n & 0xff);
|
| clientOuts.write(b);
|
| }
|
|
|
| void writeClientU32 (int n) throws IOException {
|
| byte[] b = new byte[4];
|
| b[0] = (byte) ((n >> 24) & 0xff);
|
| b[1] = (byte) ((n >> 16) & 0xff);
|
| b[2] = (byte) ((n >> 8) & 0xff);
|
| b[3] = (byte) (n & 0xff);
|
| clientOuts.write(b);
|
| }
|
|
|
| String RFB_VERSION_STRING = "RFB 003.008\n";
|
|
|
| void handleClientSession(ConsoleProxyViewer viewer, String srcinfo) throws Exception {
|
| s_logger.info("Start to handle client session");
|
|
|
| viewer.setAjaxViewer(false);
|
|
|
| // Exchange version with client
|
| clientOuts.write(RFB_VERSION_STRING.getBytes("US-ASCII"));
|
| clientOuts.flush();
|
| byte[] clientVersion = new byte[12];
|
| clientIns.readFully(clientVersion);
|
| if (!RFB_VERSION_STRING.equals(new String(clientVersion, "US-ASCII"))) {
|
| throw new Exception("Bad client version");
|
| }
|
| // Send security type -- no authentication needed
|
| byte[] serverSecurity = new byte[2];
|
| serverSecurity[0] = 1;
|
| serverSecurity[1] = 1;
|
| clientOuts.write(serverSecurity);
|
| clientOuts.flush();
|
| int clientSecurity = clientIns.read();
|
| if (clientSecurity != 1) {
|
| throw new Exception("Unsupported client security type " + clientSecurity);
|
| }
|
| byte[] serverSecResp = new byte[4];
|
| serverSecResp[0] = serverSecResp[1] = serverSecResp[2] = serverSecResp[3] = 0;
|
| clientOuts.write(serverSecResp);
|
| clientOuts.flush();
|
|
|
| // Receive and ignore client init
|
| clientIns.read();
|
|
|
| s_logger.info("Sending ServerInit w=" + viewer.rfb.framebufferWidth +
|
| " h=" + viewer.rfb.framebufferHeight +
|
| " bits=" + viewer.rfb.bitsPerPixel +
|
| " depth=" + viewer.rfb.depth +
|
| " name=" + viewer.rfb.desktopName);
|
| // Send serverInit
|
| writeClientU16(viewer.rfb.framebufferWidth);
|
| writeClientU16(viewer.rfb.framebufferHeight);
|
| clientOuts.write(viewer.rfb.bitsPerPixel);
|
| clientOuts.write(viewer.rfb.depth);
|
| clientOuts.write(viewer.rfb.bigEndian ? 1 : 0);
|
| clientOuts.write(viewer.rfb.trueColour ? 1 : 0);
|
| writeClientU16(viewer.rfb.redMax);
|
| writeClientU16(viewer.rfb.greenMax);
|
| writeClientU16(viewer.rfb.blueMax);
|
| clientOuts.write(viewer.rfb.redShift);
|
| clientOuts.write(viewer.rfb.greenShift);
|
| clientOuts.write(viewer.rfb.blueShift);
|
| byte[] pad = new byte[3];
|
| clientOuts.write(pad);
|
| writeClientU32(viewer.rfb.desktopName.length());
|
| clientOuts.write(viewer.rfb.desktopName.getBytes("US-ASCII"));
|
| clientOuts.flush();
|
|
|
| // Lock the viewer to avoid race condition
|
| synchronized (viewer) {
|
| if (viewer.clientStream != null) {
|
| s_logger.info("Disconnecting client link stream " +
|
| viewer.clientStream.hashCode() + " from " +
|
| viewer.clientStreamInfo);
|
| viewer.clientStream.close();
|
| }
|
| viewer.clientStream = clientOuts;
|
| viewer.clientStreamInfo = srcinfo;
|
| viewer.lastUsedTime = System.currentTimeMillis();
|
|
|
| s_logger.info("Setting client link stream " +
|
| viewer.clientStream.hashCode() + " from " + srcinfo);
|
| }
|
|
|
| try {
|
| while (!viewer.isDropped()) {
|
| byte[] b = new byte[512];
|
| int nbytes = 0;
|
| int msgType = clientIns.read();
|
| b[0] = (byte)msgType;
|
| switch (msgType) {
|
| case RfbProto.SetPixelFormat:
|
| clientIns.readFully(b, 1, 19);
|
| nbytes = 20;
|
|
|
| if(s_logger.isDebugEnabled())
|
| s_logger.debug("C->S RFB message SetPixelFormat, size=" + nbytes);
|
| break;
|
|
|
| case RfbProto.SetEncodings:
|
|
|
| clientIns.read(); // padding
|
| b[1] = 0;
|
| int n = clientIns.readUnsignedShort();
|
| if (n > (512 - 4)/4) {
|
| throw new Exception ("Too many client encodings");
|
| }
|
| b[2] = (byte) ((n >> 8) & 0xff);
|
| b[3] = (byte) (n & 0xff);
|
| clientIns.readFully(b, 4, n * 4);
|
| nbytes = n * 4 + 4;
|
|
|
| if(s_logger.isDebugEnabled())
|
| s_logger.debug("C->S RFB message SetEncodings, size=" + nbytes);
|
| break;
|
|
|
| case RfbProto.FramebufferUpdateRequest:
|
| clientIns.readFully(b, 1, 9);
|
| nbytes = 10;
|
|
|
| if(s_logger.isDebugEnabled()) {
|
| int i = b[1];
|
| int x = ((0xff & b[2]) << 8) + b[3];
|
| int y = ((0xff & b[4]) << 8) + b[5];
|
| int w = ((0xff & b[6]) << 8) + b[7];
|
| int h = ((0xff & b[8]) << 8) + b[9];
|
|
|
| s_logger.debug("C->S RFB message FramebufferUpdateRequest, size=" + nbytes + " x=" + x
|
| +" y=" + y + " w=" + w + " h=" + h);
|
| }
|
| break;
|
|
|
| case RfbProto.KeyboardEvent:
|
| clientIns.readFully(b, 1, 7);
|
| nbytes = 8;
|
|
|
| if(s_logger.isDebugEnabled())
|
| s_logger.debug("C->S RFB message KeyboardEvent, size=" + nbytes);
|
| break;
|
| case RfbProto.PointerEvent:
|
| clientIns.readFully(b, 1, 5);
|
| nbytes = 6;
|
|
|
| if(s_logger.isDebugEnabled())
|
| s_logger.debug("C->S RFB message PointerEvent, size=" + nbytes);
|
| break;
|
|
|
| case RfbProto.VMOpsClientCustom:
|
| clientIns.read(); // read and ignore, used to track liveliness
|
| // of the client
|
| if(s_logger.isDebugEnabled())
|
| s_logger.debug("C->S RFB message VMOpsClientCustom");
|
| break;
|
|
|
| default:
|
| if(s_logger.isDebugEnabled())
|
| s_logger.debug("C->S unknown message type: " + msgType + ", size=" + nbytes);
|
| throw new Exception("Bad client event type: " + msgType);
|
| }
|
| writeServer(viewer, b, 0, nbytes);
|
| }
|
| } finally {
|
| viewer.lastUsedTime = System.currentTimeMillis();
|
| }
|
| }
|
| }
|
