com.glavsoft.transport.Reader

Here are the examples of the java api com.glavsoft.transport.Reader taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

73 Examples 7

19 Source : Surface.java
with GNU General Public License v2.0
from Skactor

public Renderer createRenderer(Reader reader, int width, int height, PixelFormat pixelFormat) {
    this.renderer = new RendererImpl(reader, width, height, pixelFormat);
    synchronized (this.renderer) {
        this.cursor = this.renderer.getCursor();
    }
    this.init(this.renderer.getWidth(), this.renderer.getHeight());
    this.updateFrameSize();
    return this.renderer;
}

19 Source : ProtocolState.java
with GNU General Public License v2.0
from Skactor

public abstract clreplaced ProtocolState {

    protected ProtocolContext context;

    protected Logger logger;

    protected Reader reader;

    protected Writer writer;

    public ProtocolState(ProtocolContext context) {
        this.context = context;
        this.logger = context.getLogger();
        this.reader = context.getReader();
        this.writer = context.getWriter();
    }

    protected void changeStateTo(ProtocolState state) {
        this.context.changeStateTo(state);
    }

    public abstract boolean next() throws UnsupportedProtocolVersionException, TransportException, UnsupportedSecurityTypeException, AuthenticationFailedException, FatalException;
}

19 Source : ReceiverTask.java
with GNU General Public License v2.0
from Skactor

public clreplaced ReceiverTask implements Runnable {

    private static final byte FRAMEBUFFER_UPDATE = 0;

    private static final byte SET_COLOR_MAP_ENTRIES = 1;

    private static final byte BELL = 2;

    private static final byte SERVER_CUT_TEXT = 3;

    private static Logger logger = Logger.getLogger("com.glavsoft.rfb.protocol.ReceiverTask");

    private final Reader reader;

    private volatile boolean isRunning = false;

    private Renderer renderer;

    private final IRepaintController repaintController;

    private final ClipboardController clipboardController;

    private final DecodersContainer decoders;

    private FramebufferUpdateRequestMessage fullscreenFbUpdateIncrementalRequest;

    private final ProtocolContext context;

    private PixelFormat pixelFormat;

    private boolean needSendPixelFormat;

    public ReceiverTask(Reader reader, IRepaintController repaintController, ClipboardController clipboardController, DecodersContainer decoders, ProtocolContext context) {
        this.reader = reader;
        this.repaintController = repaintController;
        this.clipboardController = clipboardController;
        this.context = context;
        this.decoders = decoders;
        this.renderer = repaintController.createRenderer(reader, context.getFbWidth(), context.getFbHeight(), context.getPixelFormat());
        this.fullscreenFbUpdateIncrementalRequest = new FramebufferUpdateRequestMessage(0, 0, context.getFbWidth(), context.getFbHeight(), true);
    }

    public void run() {
        this.isRunning = true;
        while (this.isRunning) {
            try {
                byte messageId = this.reader.readByte();
                switch(messageId) {
                    case 0:
                        this.framebufferUpdateMessage();
                        break;
                    case 1:
                        logger.severe("Server message SetColorMapEntries is not implemented. Skip.");
                        this.setColorMapEntries();
                        break;
                    case 2:
                        logger.fine("Server message: Bell");
                        System.out.print("\u00007");
                        System.out.flush();
                        break;
                    case 3:
                        logger.fine("Server message: CutText (3)");
                        this.serverCutText();
                        break;
                    default:
                        logger.severe("Unsupported server message. Id = " + messageId);
                }
            } catch (TransportException var4) {
                logger.severe("Close session: " + var4.getMessage());
                if (this.isRunning) {
                    this.context.cleanUpSession("Connection closed.");
                }
                this.stopTask();
            } catch (ProtocolException var5) {
                logger.severe(var5.getMessage());
                if (this.isRunning) {
                    this.context.cleanUpSession(var5.getMessage() + "\nConnection closed.");
                }
                this.stopTask();
            } catch (CommonException var6) {
                logger.severe(var6.getMessage());
                if (this.isRunning) {
                    this.context.cleanUpSession("Connection closed.");
                }
                this.stopTask();
            } catch (Throwable var7) {
                StringWriter sw = new StringWriter();
                PrintWriter pw = new PrintWriter(sw);
                var7.printStackTrace(pw);
                if (this.isRunning) {
                    this.context.cleanUpSession(var7.getMessage() + "\n" + sw.toString());
                }
                this.stopTask();
            }
        }
    }

    private void setColorMapEntries() throws TransportException {
        this.reader.readByte();
        this.reader.readUInt16();
        int var1 = this.reader.readUInt16();
        while (var1-- > 0) {
            this.reader.readUInt16();
            this.reader.readUInt16();
            this.reader.readUInt16();
        }
    }

    private void serverCutText() throws TransportException {
        this.reader.readByte();
        this.reader.readInt16();
        int length = this.reader.readInt32() & 2147483647;
        this.clipboardController.updateSystemClipboard(this.reader.readBytes(length));
    }

    public void framebufferUpdateMessage() throws CommonException {
        this.reader.readByte();
        int numberOfRectangles = this.reader.readUInt16();
        while (numberOfRectangles-- > 0) {
            FramebufferUpdateRectangle rect = new FramebufferUpdateRectangle();
            rect.fill(this.reader);
            Decoder decoder = this.decoders.getDecoderByType(rect.getEncodingType());
            logger.finest(rect.toString() + (0 == numberOfRectangles ? "\n---" : ""));
            if (decoder != null) {
                decoder.decode(this.reader, this.renderer, rect);
                this.repaintController.repaintBitmap(rect);
            } else if (rect.getEncodingType() == EncodingType.RICH_CURSOR) {
                RichCursorDecoder.getInstance().decode(this.reader, this.renderer, rect);
                this.repaintController.repaintCursor();
            } else if (rect.getEncodingType() == EncodingType.CURSOR_POS) {
                this.renderer.decodeCursorPosition(rect);
                this.repaintController.repaintCursor();
            } else {
                if (rect.getEncodingType() != EncodingType.DESKTOP_SIZE) {
                    throw new CommonException("Unprocessed encoding: " + rect.toString());
                }
                this.fullscreenFbUpdateIncrementalRequest = new FramebufferUpdateRequestMessage(0, 0, rect.width, rect.height, true);
                synchronized (this.renderer) {
                    this.renderer = this.repaintController.createRenderer(this.reader, rect.width, rect.height, this.context.getPixelFormat());
                }
                this.context.sendMessage(new FramebufferUpdateRequestMessage(0, 0, rect.width, rect.height, false));
            }
        }
        synchronized (this) {
            if (this.needSendPixelFormat) {
                this.needSendPixelFormat = false;
                this.context.setPixelFormat(this.pixelFormat);
                this.context.sendMessage(new SetPixelFormatMessage(this.pixelFormat));
                logger.fine("sent: " + this.pixelFormat);
                this.context.sendRefreshMessage();
                logger.fine("sent: nonincremental fb update");
            } else {
                this.context.sendMessage(this.fullscreenFbUpdateIncrementalRequest);
            }
        }
    }

    public synchronized void queueUpdatePixelFormat(PixelFormat pf) {
        this.pixelFormat = pf;
        this.needSendPixelFormat = true;
    }

    public void stopTask() {
        this.isRunning = false;
    }
}

19 Source : Protocol.java
with GNU General Public License v2.0
from Skactor

public clreplaced Protocol implements ProtocolContext, IChangeSettingsListener {

    private ProtocolState state;

    private final Logger logger = Logger.getLogger("com.glavsoft.rfb.protocol");

    private final IPreplacedwordRetriever preplacedwordRetriever;

    private final ProtocolSettings settings;

    private int fbWidth;

    private int fbHeight;

    private PixelFormat pixelFormat;

    private final Reader reader;

    private final Writer writer;

    private String remoteDesktopName;

    private MessageQueue messageQueue;

    private final DecodersContainer decoders;

    private SenderTask senderTask;

    private ReceiverTask receiverTask;

    private IRfbSessionListener rfbSessionListener;

    private IRepaintController repaintController;

    private PixelFormat serverPixelFormat;

    private Thread senderThread;

    private Thread receiverThread;

    private boolean isTight;

    private String protocolVersion;

    public Protocol(Reader reader, Writer writer, IPreplacedwordRetriever preplacedwordRetriever, ProtocolSettings settings) {
        this.reader = reader;
        this.writer = writer;
        this.preplacedwordRetriever = preplacedwordRetriever;
        this.settings = settings;
        this.decoders = new DecodersContainer();
        this.decoders.instantiateDecodersWhenNeeded(settings.encodings);
        this.state = new HandshakeState(this);
    }

    public void changeStateTo(ProtocolState state) {
        this.state = state;
    }

    public void handshake() throws UnsupportedProtocolVersionException, UnsupportedSecurityTypeException, AuthenticationFailedException, TransportException, FatalException {
        while (this.state.next()) {
        }
        this.messageQueue = new MessageQueue();
    }

    public PixelFormat getPixelFormat() {
        return this.pixelFormat;
    }

    public void setPixelFormat(PixelFormat pixelFormat) {
        this.pixelFormat = pixelFormat;
        if (this.repaintController != null) {
            this.repaintController.setPixelFormat(pixelFormat);
        }
    }

    public String getRemoteDesktopName() {
        return this.remoteDesktopName;
    }

    public void setRemoteDesktopName(String name) {
        this.remoteDesktopName = name;
    }

    public int getFbWidth() {
        return this.fbWidth;
    }

    public void setFbWidth(int fbWidth) {
        this.fbWidth = fbWidth;
    }

    public int getFbHeight() {
        return this.fbHeight;
    }

    public void setFbHeight(int fbHeight) {
        this.fbHeight = fbHeight;
    }

    public IPreplacedwordRetriever getPreplacedwordRetriever() {
        return this.preplacedwordRetriever;
    }

    public ProtocolSettings getSettings() {
        return this.settings;
    }

    public Logger getLogger() {
        return this.logger;
    }

    public Writer getWriter() {
        return this.writer;
    }

    public Reader getReader() {
        return this.reader;
    }

    public void startNormalHandling(IRfbSessionListener rfbSessionListener, IRepaintController repaintController, ClipboardController clipboardController) {
        this.rfbSessionListener = rfbSessionListener;
        this.repaintController = repaintController;
        this.serverPixelFormat = this.pixelFormat;
        this.serverPixelFormat.trueColourFlag = 1;
        this.setPixelFormat(this.createPixelFormat(this.settings));
        this.sendMessage(new SetPixelFormatMessage(this.pixelFormat));
        this.logger.fine("sent: " + this.pixelFormat);
        this.sendSupportedEncodingsMessage(this.settings);
        this.settings.addListener(this);
        this.settings.addListener(repaintController);
        this.sendRefreshMessage();
        this.senderTask = new SenderTask(this.messageQueue, this.writer, this);
        this.senderThread = new Thread(this.senderTask);
        this.senderThread.start();
        this.decoders.resetDecoders();
        this.receiverTask = new ReceiverTask(this.reader, repaintController, clipboardController, this.decoders, this);
        this.receiverThread = new Thread(this.receiverTask);
        this.receiverThread.start();
    }

    public void sendMessage(ClientToServerMessage message) {
        this.messageQueue.put(message);
    }

    private void sendSupportedEncodingsMessage(ProtocolSettings settings) {
        this.decoders.instantiateDecodersWhenNeeded(settings.encodings);
        SetEncodingsMessage encodingsMessage = new SetEncodingsMessage(settings.encodings);
        this.sendMessage(encodingsMessage);
        this.logger.fine("sent: " + encodingsMessage.toString());
    }

    private PixelFormat createPixelFormat(ProtocolSettings settings) {
        int serverBigEndianFlag = this.serverPixelFormat.bigEndianFlag;
        switch(settings.getBitsPerPixel()) {
            case 0:
                return this.serverPixelFormat;
            case 3:
                return PixelFormat.create3bppPixelFormat(serverBigEndianFlag);
            case 6:
                return PixelFormat.create6bppPixelFormat(serverBigEndianFlag);
            case 8:
                return PixelFormat.create8bppBGRPixelFormat(serverBigEndianFlag);
            case 16:
                return PixelFormat.create16bppPixelFormat(serverBigEndianFlag);
            case 32:
                return PixelFormat.create32bppPixelFormat(serverBigEndianFlag);
            default:
                return PixelFormat.create32bppPixelFormat(serverBigEndianFlag);
        }
    }

    public void settingsChanged(SettingsChangedEvent e) {
        ProtocolSettings settings = (ProtocolSettings) e.getSource();
        if (settings.isChangedEncodings()) {
            this.sendSupportedEncodingsMessage(settings);
        }
        if (settings.changedBitsPerPixel() && this.receiverTask != null) {
            this.receiverTask.queueUpdatePixelFormat(this.createPixelFormat(settings));
        }
    }

    public void sendRefreshMessage() {
        this.sendMessage(new FramebufferUpdateRequestMessage(0, 0, this.fbWidth, this.fbHeight, false));
        this.logger.fine("sent: full FB Refresh");
    }

    public void cleanUpSession(String message) {
        this.cleanUpSession();
        this.rfbSessionListener.rfbSessionStopped(message);
    }

    public synchronized void cleanUpSession() {
        if (this.senderTask != null) {
            this.senderTask.stopTask();
        }
        if (this.receiverTask != null) {
            this.receiverTask.stopTask();
        }
        if (this.senderTask != null) {
            try {
                this.senderThread.join(1000L);
            } catch (InterruptedException var3) {
            }
            this.senderTask = null;
        }
        if (this.receiverTask != null) {
            try {
                this.receiverThread.join(1000L);
            } catch (InterruptedException var2) {
            }
            this.receiverTask = null;
        }
    }

    public void setTight(boolean isTight) {
        this.isTight = isTight;
    }

    public boolean isTight() {
        return this.isTight;
    }

    public void setProtocolVersion(String protocolVersion) {
        this.protocolVersion = protocolVersion;
    }

    public String getProtocolVersion() {
        return this.protocolVersion;
    }
}

19 Source : VncAuthentication.java
with GNU General Public License v2.0
from Skactor

public boolean authenticate(Reader reader, Writer writer, CapabilityContainer authCaps, IPreplacedwordRetriever preplacedwordRetriever) throws TransportException, FatalException {
    byte[] challenge = reader.readBytes(16);
    String preplacedword = preplacedwordRetriever.getPreplacedword();
    if (null == preplacedword) {
        return false;
    } else {
        byte[] key = new byte[8];
        System.arraycopy(preplacedword.getBytes(), 0, key, 0, Math.min(key.length, preplacedword.getBytes().length));
        writer.write(this.encrypt(challenge, key));
        return false;
    }
}

19 Source : TightAuthentication.java
with GNU General Public License v2.0
from Skactor

private void initAuthorization(Reader reader, Writer writer, CapabilityContainer authCaps, IPreplacedwordRetriever preplacedwordRetriever) throws UnsupportedSecurityTypeException, TransportException, FatalException {
    int authCount = reader.readInt32();
    byte[] cap = new byte[authCount];
    for (int i = 0; i < authCount; ++i) {
        RfbCapabilityInfo rfbCapabilityInfo = new RfbCapabilityInfo(reader);
        cap[i] = (byte) rfbCapabilityInfo.getCode();
        Logger.getLogger("com.glavsoft.rfb.protocol.auth").fine(rfbCapabilityInfo.toString());
    }
    AuthHandler authHandler = null;
    if (authCount > 0) {
        authHandler = SecurityTypeState.selectAuthHandler(cap, authCaps);
        for (int i = 0; i < authCount; ++i) {
            if (authCaps.isSupported(cap[i])) {
                writer.writeInt32(cap[i]);
                break;
            }
        }
    } else {
        authHandler = SecurityType.getAuthHandlerById(SecurityType.NONE_AUTHENTICATION.getId());
    }
    Logger.getLogger("com.glavsoft.rfb.protocol.auth").info("Auth capability accepted: " + authHandler.getName());
    authHandler.authenticate(reader, writer, authCaps, preplacedwordRetriever);
}

19 Source : TightAuthentication.java
with GNU General Public License v2.0
from Skactor

private void initTunnelling(Reader reader, Writer writer) throws TransportException {
    long tunnelsCount = reader.readUInt32();
    if (tunnelsCount > 0L) {
        for (int i = 0; (long) i < tunnelsCount; ++i) {
            RfbCapabilityInfo rfbCapabilityInfo = new RfbCapabilityInfo(reader);
            Logger.getLogger("com.glavsoft.rfb.protocol.auth").fine(rfbCapabilityInfo.toString());
        }
        writer.writeInt32(0);
    }
}

19 Source : TightAuthentication.java
with GNU General Public License v2.0
from Skactor

public boolean authenticate(Reader reader, Writer writer, CapabilityContainer authCaps, IPreplacedwordRetriever preplacedwordRetriever) throws TransportException, FatalException, UnsupportedSecurityTypeException {
    this.initTunnelling(reader, writer);
    this.initAuthorization(reader, writer, authCaps, preplacedwordRetriever);
    return true;
}

19 Source : NoneAuthentication.java
with GNU General Public License v2.0
from Skactor

public boolean authenticate(Reader reader, Writer writer, CapabilityContainer authCaps, IPreplacedwordRetriever preplacedwordRetriever) {
    return false;
}

19 Source : PixelFormat.java
with GNU General Public License v2.0
from Skactor

public void fill(Reader reader) throws TransportException {
    this.bitsPerPixel = reader.readByte();
    this.depth = reader.readByte();
    this.bigEndianFlag = reader.readByte();
    this.trueColourFlag = reader.readByte();
    this.redMax = reader.readInt16();
    this.greenMax = reader.readInt16();
    this.blueMax = reader.readInt16();
    this.redShift = reader.readByte();
    this.greenShift = reader.readByte();
    this.blueShift = reader.readByte();
    reader.readBytes(3);
}

19 Source : ZRLEDecoder.java
with GNU General Public License v2.0
from Skactor

public void decode(Reader reader, Renderer renderer, FramebufferUpdateRectangle rect) throws TransportException {
    int zippedLength = (int) reader.readUInt32();
    if (0 != zippedLength) {
        int length = rect.width * rect.height * renderer.getBytesPerPixel();
        byte[] bytes = this.unzip(reader, zippedLength, length);
        int offset = zippedLength;
        int maxX = rect.x + rect.width;
        int maxY = rect.y + rect.height;
        int[] palette = new int[128];
        for (int tileY = rect.y; tileY < maxY; tileY += 64) {
            int tileHeight = Math.min(maxY - tileY, 64);
            for (int tileX = rect.x; tileX < maxX; tileX += 64) {
                int tileWidth = Math.min(maxX - tileX, 64);
                int subencoding = bytes[offset++] & 255;
                boolean isRle = (subencoding & 128) != 0;
                int paletteSize = subencoding & 127;
                offset += this.readPalette(bytes, offset, renderer, palette, paletteSize);
                if (1 == subencoding) {
                    renderer.fillRect(palette[0], tileX, tileY, tileWidth, tileHeight);
                } else if (isRle) {
                    if (0 == paletteSize) {
                        offset += this.decodePlainRle(bytes, offset, renderer, tileX, tileY, tileWidth, tileHeight);
                    } else {
                        offset += this.decodePaletteRle(bytes, offset, renderer, palette, tileX, tileY, tileWidth, tileHeight, paletteSize);
                    }
                } else if (0 == paletteSize) {
                    offset += this.decodeRaw(bytes, offset, renderer, tileX, tileY, tileWidth, tileHeight);
                } else {
                    offset += this.decodePacked(bytes, offset, renderer, palette, paletteSize, tileX, tileY, tileWidth, tileHeight);
                }
            }
        }
    }
}

19 Source : ZlibDecoder.java
with GNU General Public License v2.0
from Skactor

protected byte[] unzip(Reader reader, int zippedLength, int length) throws TransportException {
    byte[] bytes = ByteBuffer.getInstance().getBuffer(zippedLength + length);
    reader.readBytes(bytes, 0, zippedLength);
    if (null == this.decoder) {
        this.decoder = new Inflater();
    }
    this.decoder.setInput(bytes, 0, zippedLength);
    try {
        this.decoder.inflate(bytes, zippedLength, length);
        return bytes;
    } catch (DataFormatException var6) {
        throw new TransportException("cannot inflate Zlib data", var6);
    }
}

19 Source : ZlibDecoder.java
with GNU General Public License v2.0
from Skactor

public void decode(Reader reader, Renderer renderer, FramebufferUpdateRectangle rect) throws TransportException {
    int zippedLength = (int) reader.readUInt32();
    if (0 != zippedLength) {
        int length = rect.width * rect.height * renderer.getBytesPerPixel();
        byte[] bytes = this.unzip(reader, zippedLength, length);
        Reader unzippedReader = new Reader(new ByteArrayInputStream(bytes, zippedLength, length));
        RawDecoder.getInstance().decode(unzippedReader, renderer, rect);
    }
}

19 Source : TightDecoder.java
with GNU General Public License v2.0
from Skactor

private int readCompactSize(Reader reader) throws TransportException {
    int b = reader.readUInt8();
    int size = b & 127;
    if ((b & 128) != 0) {
        b = reader.readUInt8();
        size += (b & 127) << 7;
        if ((b & 128) != 0) {
            size += reader.readUInt8() << 14;
        }
    }
    return size;
}

19 Source : TightDecoder.java
with GNU General Public License v2.0
from Skactor

private int[] readPalette(int paletteSize, Reader reader, Renderer renderer) throws TransportException {
    int[] palette = new int[paletteSize];
    for (int i = 0; i < palette.length; ++i) {
        palette[i] = renderer.readTightPixelColor(reader);
    }
    return palette;
}

19 Source : TightDecoder.java
with GNU General Public License v2.0
from Skactor

private byte[] readCompressedData(int expectedLength, Reader reader) throws TransportException {
    int rawDataLength = this.readCompactSize(reader);
    byte[] buffer = ByteBuffer.getInstance().getBuffer(expectedLength + rawDataLength);
    reader.readBytes(buffer, expectedLength, rawDataLength);
    if (null == this.decoders[this.decoderId]) {
        this.decoders[this.decoderId] = new Inflater();
    }
    Inflater decoder = this.decoders[this.decoderId];
    decoder.setInput(buffer, expectedLength, rawDataLength);
    try {
        decoder.inflate(buffer, 0, expectedLength);
        return buffer;
    } catch (DataFormatException var7) {
        logger.throwing("TightDecoder", "readCompressedData", var7);
        throw new TransportException("cannot inflate tight compressed data", var7);
    }
}

19 Source : TightDecoder.java
with GNU General Public License v2.0
from Skactor

public void decode(Reader reader, Renderer renderer, FramebufferUpdateRectangle rect) throws TransportException {
    int bytesPerPixel = renderer.getBytesPerPixelSignificant();
    int compControl = reader.readUInt8();
    this.resetDecoders(compControl);
    int compType = compControl >> 4 & 15;
    switch(compType) {
        case 8:
            int color = renderer.readTightPixelColor(reader);
            renderer.fillRect(color, rect);
            break;
        case 9:
            if (bytesPerPixel != 3) {
            }
            this.processJpegType(reader, renderer, rect);
            break;
        default:
            if (compType <= 9) {
                this.processBasicType(compControl, reader, renderer, rect);
            }
    }
}

19 Source : TightDecoder.java
with GNU General Public License v2.0
from Skactor

private byte[] readTightData(int expectedLength, Reader reader) throws TransportException {
    if (expectedLength < 12) {
        byte[] buffer = ByteBuffer.getInstance().getBuffer(expectedLength);
        reader.readBytes(buffer, 0, expectedLength);
        return buffer;
    } else {
        return this.readCompressedData(expectedLength, reader);
    }
}

19 Source : RREDecoder.java
with GNU General Public License v2.0
from Skactor

public void decode(Reader reader, Renderer renderer, FramebufferUpdateRectangle rect) throws TransportException {
    int numOfSubrectangles = reader.readInt32();
    int color = renderer.readPixelColor(reader);
    renderer.fillRect(color, rect);
    for (int i = 0; i < numOfSubrectangles; ++i) {
        color = renderer.readPixelColor(reader);
        int x = reader.readUInt16();
        int y = reader.readUInt16();
        int width = reader.readUInt16();
        int height = reader.readUInt16();
        renderer.fillRect(color, rect.x + x, rect.y + y, width, height);
    }
}

19 Source : RawDecoder.java
with GNU General Public License v2.0
from Skactor

public void decode(Reader reader, Renderer renderer, FramebufferUpdateRectangle rect) throws TransportException {
    this.decode(reader, renderer, rect.x, rect.y, rect.width, rect.height);
}

19 Source : HextileDecoder.java
with GNU General Public License v2.0
from Skactor

private void decodeHextileSubrectangle(Reader reader, Renderer renderer, int[] colors, int tileX, int tileY, int tileWidth, int tileHeight) throws TransportException {
    int subencoding = reader.readUInt8();
    if ((subencoding & 1) != 0) {
        RawDecoder.getInstance().decode(reader, renderer, tileX, tileY, tileWidth, tileHeight);
    } else {
        if ((subencoding & 2) != 0) {
            colors[1] = renderer.readPixelColor(reader);
        }
        replacedert colors[1] != -1;
        renderer.fillRect(colors[1], tileX, tileY, tileWidth, tileHeight);
        if ((subencoding & 4) != 0) {
            colors[0] = renderer.readPixelColor(reader);
        }
        if ((subencoding & 8) != 0) {
            int numberOfSubrectangles = reader.readUInt8();
            boolean colorSpecified = (subencoding & 16) != 0;
            for (int i = 0; i < numberOfSubrectangles; ++i) {
                if (colorSpecified) {
                    colors[0] = renderer.readPixelColor(reader);
                }
                byte dimensions = reader.readByte();
                int subtileX = dimensions >> 4 & 15;
                int subtileY = dimensions & 15;
                dimensions = reader.readByte();
                int subtileWidth = 1 + (dimensions >> 4 & 15);
                int subtileHeight = 1 + (dimensions & 15);
                replacedert colors[0] != -1;
                renderer.fillRect(colors[0], tileX + subtileX, tileY + subtileY, subtileWidth, subtileHeight);
            }
        }
    }
}

19 Source : HextileDecoder.java
with GNU General Public License v2.0
from Skactor

public void decode(Reader reader, Renderer renderer, FramebufferUpdateRectangle rect) throws TransportException {
    if (rect.width != 0 && rect.height != 0) {
        int[] colors = new int[] { -1, -1 };
        int maxX = rect.x + rect.width;
        int maxY = rect.y + rect.height;
        for (int tileY = rect.y; tileY < maxY; tileY += 16) {
            int tileHeight = Math.min(maxY - tileY, 16);
            for (int tileX = rect.x; tileX < maxX; tileX += 16) {
                int tileWidth = Math.min(maxX - tileX, 16);
                this.decodeHextileSubrectangle(reader, renderer, colors, tileX, tileY, tileWidth, tileHeight);
            }
        }
    }
}

19 Source : FramebufferUpdateRectangle.java
with GNU General Public License v2.0
from Skactor

public void fill(Reader reader) throws TransportException {
    this.x = reader.readUInt16();
    this.y = reader.readUInt16();
    this.width = reader.readUInt16();
    this.height = reader.readUInt16();
    int encoding = reader.readInt32();
    this.encodingType = EncodingType.byId(encoding);
}

19 Source : CopyRectDecoder.java
with GNU General Public License v2.0
from Skactor

public void decode(Reader reader, Renderer renderer, FramebufferUpdateRectangle rect) throws TransportException {
    int srcX = reader.readUInt16();
    int srcY = reader.readUInt16();
    if (rect.width != 0 && rect.height != 0) {
        renderer.copyRect(srcX, srcY, rect);
    }
}

19 Source : CapabilityContainer.java
with GNU General Public License v2.0
from Skactor

public void read(Reader reader, int count) throws TransportException {
    while (count-- > 0) {
        RfbCapabilityInfo capInfoReceived = new RfbCapabilityInfo(reader);
        Logger.getLogger("com.glavsoft.rfb").fine(capInfoReceived.toString());
        RfbCapabilityInfo myCapInfo = (RfbCapabilityInfo) this.caps.get(capInfoReceived.getCode());
        if (myCapInfo != null) {
            myCapInfo.setEnable(true);
        }
    }
}

19 Source : Renderer.java
with GNU General Public License v2.0
from Skactor

public abstract clreplaced Renderer {

    protected Reader reader;

    protected int width;

    protected int height;

    protected int bytesPerPixel;

    protected int bytesPerPixelSignificant;

    protected int[] pixels;

    protected SoftCursor cursor;

    protected PixelFormat pixelFormat;

    private ColorDecoder colorDecoder;

    public Renderer() {
    }

    public abstract void drawJpegImage(byte[] var1, int var2, int var3, FramebufferUpdateRectangle var4);

    protected void init(Reader reader, int width, int height, PixelFormat pixelFormat) {
        this.reader = reader;
        this.width = width;
        this.height = height;
        this.initPixelFormat(pixelFormat);
        this.pixels = new int[width * height];
        Arrays.fill(this.pixels, 0);
    }

    public synchronized void initPixelFormat(PixelFormat pixelFormat) {
        this.pixelFormat = pixelFormat;
        this.bytesPerPixel = pixelFormat.bitsPerPixel / 8;
        this.bytesPerPixelSignificant = 24 == pixelFormat.depth && 32 == pixelFormat.bitsPerPixel ? 3 : this.bytesPerPixel;
        this.colorDecoder = new ColorDecoder(pixelFormat);
    }

    public void drawBytes(byte[] bytes, int x, int y, int width, int height) {
        int i = 0;
        for (int ly = y; ly < y + height; ++ly) {
            int end = ly * this.width + x + width;
            for (int pixelsOffset = ly * this.width + x; pixelsOffset < end; ++pixelsOffset) {
                this.pixels[pixelsOffset] = this.getPixelColor(bytes, i);
                i += this.bytesPerPixel;
            }
        }
    }

    public synchronized int drawCompactBytes(byte[] bytes, int offset, int x, int y, int width, int height) {
        int i = offset;
        for (int ly = y; ly < y + height; ++ly) {
            int end = ly * this.width + x + width;
            for (int pixelsOffset = ly * this.width + x; pixelsOffset < end; ++pixelsOffset) {
                this.pixels[pixelsOffset] = this.getCompactPixelColor(bytes, i);
                i += this.bytesPerPixelSignificant;
            }
        }
        return i - offset;
    }

    public synchronized void drawColoredBitmap(int[] colors, int x, int y, int width, int height) {
        int i = 0;
        for (int ly = y; ly < y + height; ++ly) {
            int end = ly * this.width + x + width;
            for (int pixelsOffset = ly * this.width + x; pixelsOffset < end; ++pixelsOffset) {
                this.pixels[pixelsOffset] = colors[i++];
            }
        }
    }

    public synchronized int drawTightBytes(byte[] bytes, int offset, int x, int y, int width, int height) {
        int i = offset;
        for (int ly = y; ly < y + height; ++ly) {
            int end = ly * this.width + x + width;
            for (int pixelsOffset = ly * this.width + x; pixelsOffset < end; ++pixelsOffset) {
                this.pixels[pixelsOffset] = this.colorDecoder.getTightColor(bytes, i);
                i += this.bytesPerPixelSignificant;
            }
        }
        return i - offset;
    }

    public synchronized void drawUncaliberedRGBLine(byte[] bytes, int x, int y, int width) {
        int end = y * this.width + x + width;
        int i = 3;
        for (int pixelsOffset = y * this.width + x; pixelsOffset < end; ++pixelsOffset) {
            this.pixels[pixelsOffset] = (255 & 255 * (this.colorDecoder.redMax & bytes[i++]) / this.colorDecoder.redMax) << 16 | (255 & 255 * (this.colorDecoder.greenMax & bytes[i++]) / this.colorDecoder.greenMax) << 8 | 255 & 255 * (this.colorDecoder.blueMax & bytes[i++]) / this.colorDecoder.blueMax;
        }
    }

    public synchronized void drawBytesWithPalette(byte[] buffer, FramebufferUpdateRectangle rect, int[] palette) {
        int dx;
        int dy;
        int n;
        int i;
        if (palette.length == 2) {
            i = rect.y * this.width + rect.x;
            int rowBytes = (rect.width + 7) / 8;
            for (dy = 0; dy < rect.height; ++dy) {
                for (dx = 0; dx < rect.width / 8; ++dx) {
                    byte b = buffer[dy * rowBytes + dx];
                    for (n = 7; n >= 0; --n) {
                        this.pixels[i++] = palette[b >> n & 1];
                    }
                }
                for (n = 7; n >= 8 - rect.width % 8; --n) {
                    this.pixels[i++] = palette[buffer[dy * rowBytes + dx] >> n & 1];
                }
                i += this.width - rect.width;
            }
        } else {
            dx = 0;
            for (dy = rect.y; dy < rect.y + rect.height; ++dy) {
                for (n = rect.x; n < rect.x + rect.width; ++n) {
                    i = dy * this.width + n;
                    this.pixels[i] = palette[buffer[dx++] & 255];
                }
            }
        }
    }

    public synchronized void copyRect(int srcX, int srcY, FramebufferUpdateRectangle dstRect) {
        int startSrcY;
        int endSrcY;
        int dstY;
        byte deltaY;
        if (srcY > dstRect.y) {
            startSrcY = srcY;
            endSrcY = srcY + dstRect.height;
            dstY = dstRect.y;
            deltaY = 1;
        } else {
            startSrcY = srcY + dstRect.height - 1;
            endSrcY = srcY - 1;
            dstY = dstRect.y + dstRect.height - 1;
            deltaY = -1;
        }
        for (int y = startSrcY; y != endSrcY; y += deltaY) {
            System.arraycopy(this.pixels, y * this.width + srcX, this.pixels, dstY * this.width + dstRect.x, dstRect.width);
            dstY += deltaY;
        }
    }

    public void fillRect(int color, FramebufferUpdateRectangle rect) {
        this.fillRect(color, rect.x, rect.y, rect.width, rect.height);
    }

    public synchronized void fillRect(int color, int x, int y, int width, int height) {
        int sy = y * this.width + x;
        int ey = sy + height * this.width;
        for (int i = sy; i < ey; i += this.width) {
            Arrays.fill(this.pixels, i, i + width, color);
        }
    }

    public int readPixelColor(Reader reader) throws TransportException {
        return this.colorDecoder.readColor(reader);
    }

    public int readTightPixelColor(Reader reader) throws TransportException {
        return this.colorDecoder.readTightColor(reader);
    }

    public ColorDecoder getColorDecoder() {
        return this.colorDecoder;
    }

    public int getCompactPixelColor(byte[] bytes, int offset) {
        return this.colorDecoder.getCompactColor(bytes, offset);
    }

    public int getPixelColor(byte[] bytes, int offset) {
        return this.colorDecoder.getColor(bytes, offset);
    }

    public int getBytesPerPixel() {
        return this.bytesPerPixel;
    }

    public int getBytesPerPixelSignificant() {
        return this.bytesPerPixelSignificant;
    }

    public void fillColorBitmapWithColor(int[] bitmapData, int decodedOffset, int rlength, int color) {
        while (rlength-- > 0) {
            bitmapData[decodedOffset++] = color;
        }
    }

    public int getWidth() {
        return this.width;
    }

    public int getHeight() {
        return this.height;
    }

    public void createCursor(int[] cursorPixels, FramebufferUpdateRectangle rect) throws TransportException {
        synchronized (this.cursor) {
            this.cursor.createCursor(cursorPixels, rect.x, rect.y, rect.width, rect.height);
        }
    }

    public void decodeCursorPosition(FramebufferUpdateRectangle rect) {
        synchronized (this.cursor) {
            this.cursor.updatePosition(rect.x, rect.y);
        }
    }
}

19 Source : Renderer.java
with GNU General Public License v2.0
from Skactor

public int readTightPixelColor(Reader reader) throws TransportException {
    return this.colorDecoder.readTightColor(reader);
}

19 Source : Renderer.java
with GNU General Public License v2.0
from Skactor

protected void init(Reader reader, int width, int height, PixelFormat pixelFormat) {
    this.reader = reader;
    this.width = width;
    this.height = height;
    this.initPixelFormat(pixelFormat);
    this.pixels = new int[width * height];
    Arrays.fill(this.pixels, 0);
}

19 Source : Renderer.java
with GNU General Public License v2.0
from Skactor

public int readPixelColor(Reader reader) throws TransportException {
    return this.colorDecoder.readColor(reader);
}

19 Source : ColorDecoder.java
with GNU General Public License v2.0
from Skactor

protected int readTightColor(Reader reader) throws TransportException {
    return this.getTightColor(reader.readBytes(this.buff, 0, this.bytesPerPixelSignificant), 0);
}

19 Source : ColorDecoder.java
with GNU General Public License v2.0
from Skactor

protected int readColor(Reader reader) throws TransportException {
    return this.getColor(reader.readBytes(this.buff, 0, this.bytesPerPixel), 0);
}

19 Source : ColorDecoder.java
with GNU General Public License v2.0
from Skactor

protected int readCompactColor(Reader reader) throws TransportException {
    return this.getCompactColor(reader.readBytes(this.buff, 0, this.bytesPerPixelSignificant), 0);
}

19 Source : Surface.java
with GNU General Public License v2.0
from Freakboy

@Override
public Renderer createRenderer(Reader reader, int width, int height, PixelFormat pixelFormat) {
    renderer = new RendererImpl(reader, width, height, pixelFormat);
    synchronized (renderer) {
        cursor = renderer.getCursor();
    }
    init(renderer.getWidth(), renderer.getHeight());
    updateFrameSize();
    return renderer;
}

19 Source : ProtocolState.java
with GNU General Public License v2.0
from Freakboy

abstract public clreplaced ProtocolState {

    protected ProtocolContext context;

    protected Logger logger;

    protected Reader reader;

    protected Writer writer;

    public ProtocolState(ProtocolContext context) {
        this.context = context;
        this.logger = context.getLogger();
        this.reader = context.getReader();
        this.writer = context.getWriter();
    }

    /**
     * Change state of finite machine.
     *
     * @param state state, the Finite Machine will switched to
     */
    protected void changeStateTo(ProtocolState state) {
        context.changeStateTo(state);
    }

    /**
     * Carry out next step of protocol flow.
     *
     * @return false when no next protocol steps availabe, true - when need to continue
     */
    abstract public boolean next() throws UnsupportedProtocolVersionException, TransportException, UnsupportedSecurityTypeException, AuthenticationFailedException, FatalException;
}

19 Source : ReceiverTask.java
with GNU General Public License v2.0
from Freakboy

public clreplaced ReceiverTask implements Runnable {

    private static final byte FRAMEBUFFER_UPDATE = 0;

    private static final byte SET_COLOR_MAP_ENTRIES = 1;

    private static final byte BELL = 2;

    private static final byte SERVER_CUT_TEXT = 3;

    private static Logger logger = Logger.getLogger("com.glavsoft.rfb.protocol.ReceiverTask");

    private final Reader reader;

    private volatile boolean isRunning = false;

    private Renderer renderer;

    private final IRepaintController repaintController;

    private final ClipboardController clipboardController;

    private final DecodersContainer decoders;

    private FramebufferUpdateRequestMessage fullscreenFbUpdateIncrementalRequest;

    private final ProtocolContext context;

    private PixelFormat pixelFormat;

    private boolean needSendPixelFormat;

    public ReceiverTask(Reader reader, IRepaintController repaintController, ClipboardController clipboardController, DecodersContainer decoders, ProtocolContext context) {
        this.reader = reader;
        this.repaintController = repaintController;
        this.clipboardController = clipboardController;
        this.context = context;
        this.decoders = decoders;
        renderer = repaintController.createRenderer(reader, context.getFbWidth(), context.getFbHeight(), context.getPixelFormat());
        fullscreenFbUpdateIncrementalRequest = new FramebufferUpdateRequestMessage(0, 0, context.getFbWidth(), context.getFbHeight(), true);
    }

    @Override
    public void run() {
        isRunning = true;
        while (isRunning) {
            try {
                byte messageId = reader.readByte();
                switch(messageId) {
                    case FRAMEBUFFER_UPDATE:
                        // logger.fine("Server message: FramebufferUpdate (0)");
                        framebufferUpdateMessage();
                        break;
                    case SET_COLOR_MAP_ENTRIES:
                        logger.severe("Server message SetColorMapEntries is not implemented. Skip.");
                        setColorMapEntries();
                        break;
                    case BELL:
                        logger.fine("Server message: Bell");
                        System.out.print("\0007");
                        System.out.flush();
                        break;
                    case SERVER_CUT_TEXT:
                        logger.fine("Server message: CutText (3)");
                        serverCutText();
                        break;
                    default:
                        logger.severe("Unsupported server message. Id = " + messageId);
                }
            } catch (TransportException e) {
                logger.severe("Close session: " + e.getMessage());
                if (isRunning) {
                    context.cleanUpSession("Connection closed.");
                }
                stopTask();
            } catch (ProtocolException e) {
                logger.severe(e.getMessage());
                if (isRunning) {
                    context.cleanUpSession(e.getMessage() + "\nConnection closed.");
                }
                stopTask();
            } catch (CommonException e) {
                logger.severe(e.getMessage());
                if (isRunning) {
                    context.cleanUpSession("Connection closed.");
                }
                stopTask();
            } catch (Throwable te) {
                StringWriter sw = new StringWriter();
                PrintWriter pw = new PrintWriter(sw);
                te.printStackTrace(pw);
                if (isRunning) {
                    context.cleanUpSession(te.getMessage() + "\n" + sw.toString());
                }
                stopTask();
            }
        }
    }

    private void setColorMapEntries() throws TransportException {
        // padding
        reader.readByte();
        // first color index
        reader.readUInt16();
        int length = reader.readUInt16();
        while (length-- > 0) {
            // R
            reader.readUInt16();
            // G
            reader.readUInt16();
            // B
            reader.readUInt16();
        }
    }

    private void serverCutText() throws TransportException {
        // padding
        reader.readByte();
        // padding
        reader.readInt16();
        int length = reader.readInt32() & Integer.MAX_VALUE;
        clipboardController.updateSystemClipboard(reader.readBytes(length));
    }

    public void framebufferUpdateMessage() throws CommonException {
        // padding
        reader.readByte();
        int numberOfRectangles = reader.readUInt16();
        while (numberOfRectangles-- > 0) {
            FramebufferUpdateRectangle rect = new FramebufferUpdateRectangle();
            rect.fill(reader);
            Decoder decoder = decoders.getDecoderByType(rect.getEncodingType());
            logger.finest(rect.toString() + (0 == numberOfRectangles ? "\n---" : ""));
            if (decoder != null) {
                decoder.decode(reader, renderer, rect);
                repaintController.repaintBitmap(rect);
            } else if (rect.getEncodingType() == EncodingType.RICH_CURSOR) {
                RichCursorDecoder.getInstance().decode(reader, renderer, rect);
                repaintController.repaintCursor();
            } else if (rect.getEncodingType() == EncodingType.CURSOR_POS) {
                renderer.decodeCursorPosition(rect);
                repaintController.repaintCursor();
            } else if (rect.getEncodingType() == EncodingType.DESKTOP_SIZE) {
                fullscreenFbUpdateIncrementalRequest = new FramebufferUpdateRequestMessage(0, 0, rect.width, rect.height, true);
                synchronized (renderer) {
                    renderer = repaintController.createRenderer(reader, rect.width, rect.height, context.getPixelFormat());
                }
                context.sendMessage(new FramebufferUpdateRequestMessage(0, 0, rect.width, rect.height, false));
            // repaintController.repaintCursor();
            } else
                throw new CommonException("Unprocessed encoding: " + rect.toString());
        }
        synchronized (this) {
            if (needSendPixelFormat) {
                needSendPixelFormat = false;
                context.setPixelFormat(pixelFormat);
                context.sendMessage(new SetPixelFormatMessage(pixelFormat));
                logger.fine("sent: " + pixelFormat);
                context.sendRefreshMessage();
                logger.fine("sent: nonincremental fb update");
            } else {
                context.sendMessage(fullscreenFbUpdateIncrementalRequest);
            }
        }
    }

    public synchronized void queueUpdatePixelFormat(PixelFormat pf) {
        pixelFormat = pf;
        needSendPixelFormat = true;
    // context.sendMessage(new FramebufferUpdateRequestMessage(0, 0, 1, 1, false));
    }

    public void stopTask() {
        isRunning = false;
    }
}

19 Source : Protocol.java
with GNU General Public License v2.0
from Freakboy

public clreplaced Protocol implements ProtocolContext, IChangeSettingsListener {

    private ProtocolState state;

    private final Logger logger = Logger.getLogger("com.glavsoft.rfb.protocol");

    private final IPreplacedwordRetriever preplacedwordRetriever;

    private final ProtocolSettings settings;

    private int fbWidth;

    private int fbHeight;

    private PixelFormat pixelFormat;

    private final Reader reader;

    private final Writer writer;

    private String remoteDesktopName;

    private MessageQueue messageQueue;

    private final DecodersContainer decoders;

    private SenderTask senderTask;

    private ReceiverTask receiverTask;

    private IRfbSessionListener rfbSessionListener;

    private IRepaintController repaintController;

    private PixelFormat serverPixelFormat;

    private Thread senderThread;

    private Thread receiverThread;

    private boolean isTight;

    private String protocolVersion;

    public Protocol(Reader reader, Writer writer, IPreplacedwordRetriever preplacedwordRetriever, ProtocolSettings settings) {
        this.reader = reader;
        this.writer = writer;
        this.preplacedwordRetriever = preplacedwordRetriever;
        this.settings = settings;
        decoders = new DecodersContainer();
        decoders.instantiateDecodersWhenNeeded(settings.encodings);
        state = new HandshakeState(this);
    }

    @Override
    public void changeStateTo(ProtocolState state) {
        this.state = state;
    }

    public void handshake() throws UnsupportedProtocolVersionException, UnsupportedSecurityTypeException, AuthenticationFailedException, TransportException, FatalException {
        while (state.next()) {
        // continue;
        }
        this.messageQueue = new MessageQueue();
    }

    @Override
    public PixelFormat getPixelFormat() {
        return pixelFormat;
    }

    @Override
    public void setPixelFormat(PixelFormat pixelFormat) {
        this.pixelFormat = pixelFormat;
        if (repaintController != null) {
            repaintController.setPixelFormat(pixelFormat);
        }
    }

    @Override
    public String getRemoteDesktopName() {
        return remoteDesktopName;
    }

    @Override
    public void setRemoteDesktopName(String name) {
        remoteDesktopName = name;
    }

    @Override
    public int getFbWidth() {
        return fbWidth;
    }

    @Override
    public void setFbWidth(int fbWidth) {
        this.fbWidth = fbWidth;
    }

    @Override
    public int getFbHeight() {
        return fbHeight;
    }

    @Override
    public void setFbHeight(int fbHeight) {
        this.fbHeight = fbHeight;
    }

    @Override
    public IPreplacedwordRetriever getPreplacedwordRetriever() {
        return preplacedwordRetriever;
    }

    @Override
    public ProtocolSettings getSettings() {
        return settings;
    }

    @Override
    public Logger getLogger() {
        return logger;
    }

    @Override
    public Writer getWriter() {
        return writer;
    }

    @Override
    public Reader getReader() {
        return reader;
    }

    /**
     * Following the server initialisation message it's up to the client to send
     * whichever protocol messages it wants.  Typically it will send a
     * SetPixelFormat message and a SetEncodings message, followed by a
     * FramebufferUpdateRequest.  From then on the server will send
     * FramebufferUpdate messages in response to the client's
     * FramebufferUpdateRequest messages.  The client should send
     * FramebufferUpdateRequest messages with incremental set to true when it has
     * finished processing one FramebufferUpdate and is ready to process another.
     * With a fast client, the rate at which FramebufferUpdateRequests are sent
     * should be regulated to avoid hogging the network.
     */
    public void startNormalHandling(IRfbSessionListener rfbSessionListener, IRepaintController repaintController, ClipboardController clipboardController) {
        this.rfbSessionListener = rfbSessionListener;
        this.repaintController = repaintController;
        // if (settings.getBitsPerPixel() == 0) {
        // settings.setBitsPerPixel(pixelFormat.bitsPerPixel); // the same the server sent when not initialized yet
        // }
        serverPixelFormat = pixelFormat;
        // correct flag - we don't support color maps
        serverPixelFormat.trueColourFlag = 1;
        setPixelFormat(createPixelFormat(settings));
        sendMessage(new SetPixelFormatMessage(pixelFormat));
        logger.fine("sent: " + pixelFormat);
        sendSupportedEncodingsMessage(settings);
        // to support pixel format (color depth), and encodings changes
        settings.addListener(this);
        settings.addListener(repaintController);
        sendRefreshMessage();
        senderTask = new SenderTask(messageQueue, writer, this);
        senderThread = new Thread(senderTask);
        senderThread.start();
        decoders.resetDecoders();
        receiverTask = new ReceiverTask(reader, repaintController, clipboardController, decoders, this);
        receiverThread = new Thread(receiverTask);
        receiverThread.start();
    }

    @Override
    public void sendMessage(ClientToServerMessage message) {
        messageQueue.put(message);
    }

    private void sendSupportedEncodingsMessage(ProtocolSettings settings) {
        decoders.instantiateDecodersWhenNeeded(settings.encodings);
        SetEncodingsMessage encodingsMessage = new SetEncodingsMessage(settings.encodings);
        sendMessage(encodingsMessage);
        logger.fine("sent: " + encodingsMessage.toString());
    }

    /**
     * create pixel format by bpp
     */
    private PixelFormat createPixelFormat(ProtocolSettings settings) {
        int serverBigEndianFlag = serverPixelFormat.bigEndianFlag;
        switch(settings.getBitsPerPixel()) {
            case ProtocolSettings.BPP_32:
                return PixelFormat.create32bppPixelFormat(serverBigEndianFlag);
            case ProtocolSettings.BPP_16:
                return PixelFormat.create16bppPixelFormat(serverBigEndianFlag);
            case ProtocolSettings.BPP_8:
                return PixelFormat.create8bppBGRPixelFormat(serverBigEndianFlag);
            case ProtocolSettings.BPP_6:
                return PixelFormat.create6bppPixelFormat(serverBigEndianFlag);
            case ProtocolSettings.BPP_3:
                return PixelFormat.create3bppPixelFormat(serverBigEndianFlag);
            case ProtocolSettings.BPP_SERVER_SETTINGS:
                return serverPixelFormat;
            default:
                // unsupported bpp, use default
                return PixelFormat.create32bppPixelFormat(serverBigEndianFlag);
        }
    }

    @Override
    public void settingsChanged(SettingsChangedEvent e) {
        ProtocolSettings settings = (ProtocolSettings) e.getSource();
        if (settings.isChangedEncodings()) {
            sendSupportedEncodingsMessage(settings);
        }
        if (settings.changedBitsPerPixel() && receiverTask != null) {
            receiverTask.queueUpdatePixelFormat(createPixelFormat(settings));
        }
    }

    @Override
    public void sendRefreshMessage() {
        sendMessage(new FramebufferUpdateRequestMessage(0, 0, fbWidth, fbHeight, false));
        logger.fine("sent: full FB Refresh");
    }

    @Override
    public void cleanUpSession(String message) {
        cleanUpSession();
        rfbSessionListener.rfbSessionStopped(message);
    }

    public synchronized void cleanUpSession() {
        if (senderTask != null) {
            senderTask.stopTask();
        }
        if (receiverTask != null) {
            receiverTask.stopTask();
        }
        if (senderTask != null) {
            try {
                senderThread.join(1000);
            } catch (InterruptedException e) {
            // nop
            }
            senderTask = null;
        }
        if (receiverTask != null) {
            try {
                receiverThread.join(1000);
            } catch (InterruptedException e) {
            // nop
            }
            receiverTask = null;
        }
    }

    @Override
    public void setTight(boolean isTight) {
        this.isTight = isTight;
    }

    @Override
    public boolean isTight() {
        return isTight;
    }

    @Override
    public void setProtocolVersion(String protocolVersion) {
        this.protocolVersion = protocolVersion;
    }

    @Override
    public String getProtocolVersion() {
        return protocolVersion;
    }
}

19 Source : VncAuthentication.java
with GNU General Public License v2.0
from Freakboy

@Override
public boolean authenticate(Reader reader, Writer writer, CapabilityContainer authCaps, IPreplacedwordRetriever preplacedwordRetriever) throws TransportException, FatalException {
    byte[] challenge = reader.readBytes(16);
    String preplacedword = preplacedwordRetriever.getPreplacedword();
    if (null == preplacedword)
        return false;
    byte[] key = new byte[8];
    System.arraycopy(preplacedword.getBytes(), 0, key, 0, Math.min(key.length, preplacedword.getBytes().length));
    writer.write(encrypt(challenge, key));
    return false;
}

19 Source : TightAuthentication.java
with GNU General Public License v2.0
from Freakboy

/**
 * Negotiation of Authentication Capabilities (protocol versions 3.7t, 3.8t)
 *
 * After setting up tunneling, the server sends a list of supported
 * authentication schemes.
 *
 * nAuthTypes specifies the number of following rfbCapabilityInfo structures
 * that list all supported authentication schemes in the order of preference.
 *
 * NOTE: If nAuthTypes is 0, that tells the client that no authentication is
 * necessary, and the client should not send a response requesting an
 * authentication scheme.
 *
 * typedef struct _rfbAuthenticationCapsMsg {
 *     CARD32 nAuthTypes;
 *     // followed by nAuthTypes * rfbCapabilityInfo structures
 * } rfbAuthenticationCapsMsg;
 * #define sz_rfbAuthenticationCapsMsg 4
 * @param authCaps TODO
 * @param preplacedwordRetriever
 * @throws UnsupportedSecurityTypeException
 * @throws TransportException
 * @throws FatalException
 */
private void initAuthorization(Reader reader, Writer writer, CapabilityContainer authCaps, IPreplacedwordRetriever preplacedwordRetriever) throws UnsupportedSecurityTypeException, TransportException, FatalException {
    int authCount;
    authCount = reader.readInt32();
    byte[] cap = new byte[authCount];
    for (int i = 0; i < authCount; ++i) {
        RfbCapabilityInfo rfbCapabilityInfo = new RfbCapabilityInfo(reader);
        cap[i] = (byte) rfbCapabilityInfo.getCode();
        Logger.getLogger("com.glavsoft.rfb.protocol.auth").fine(rfbCapabilityInfo.toString());
    }
    AuthHandler authHandler = null;
    if (authCount > 0) {
        authHandler = SecurityTypeState.selectAuthHandler(cap, authCaps);
        for (int i = 0; i < authCount; ++i) {
            if (authCaps.isSupported(cap[i])) {
                // sending back RFB capability code
                writer.writeInt32(cap[i]);
                break;
            }
        }
    } else {
        authHandler = SecurityType.getAuthHandlerById(SecurityType.NONE_AUTHENTICATION.getId());
    }
    Logger.getLogger("com.glavsoft.rfb.protocol.auth").info("Auth capability accepted: " + authHandler.getName());
    authHandler.authenticate(reader, writer, authCaps, preplacedwordRetriever);
}

19 Source : TightAuthentication.java
with GNU General Public License v2.0
from Freakboy

/**
 * Negotiation of Tunneling Capabilities (protocol versions 3.7t, 3.8t)
 *
 * If the chosen security type is rfbSecTypeTight, the server sends a list of
 * supported tunneling methods ("tunneling" refers to any additional layer of
 * data transformation, such as encryption or external compression.)
 *
 * nTunnelTypes specifies the number of following rfbCapabilityInfo structures
 * that list all supported tunneling methods in the order of preference.
 *
 * NOTE: If nTunnelTypes is 0, that tells the client that no tunneling can be
 * used, and the client should not send a response requesting a tunneling
 * method.
 *
 * typedef struct _rfbTunnelingCapsMsg {
 *     CARD32 nTunnelTypes;
 *     //followed by nTunnelTypes * rfbCapabilityInfo structures
 *  } rfbTunnelingCapsMsg;
 * #define sz_rfbTunnelingCapsMsg 4
 * ----------------------------------------------------------------------------
 * Tunneling Method Request (protocol versions 3.7t, 3.8t)
 *
 * If the list of tunneling capabilities sent by the server was not empty, the
 * client should reply with a 32-bit code specifying a particular tunneling
 * method.  The following code should be used for no tunneling.
 *
 * #define rfbNoTunneling 0
 * #define sig_rfbNoTunneling "NOTUNNEL"
 */
private void initTunnelling(Reader reader, Writer writer) throws TransportException {
    long tunnelsCount;
    tunnelsCount = reader.readUInt32();
    if (tunnelsCount > 0) {
        for (int i = 0; i < tunnelsCount; ++i) {
            RfbCapabilityInfo rfbCapabilityInfo = new RfbCapabilityInfo(reader);
            Logger.getLogger("com.glavsoft.rfb.protocol.auth").fine(rfbCapabilityInfo.toString());
        }
        // NOTUNNEL
        writer.writeInt32(0);
    }
}

19 Source : TightAuthentication.java
with GNU General Public License v2.0
from Freakboy

@Override
public boolean authenticate(Reader reader, Writer writer, CapabilityContainer authCaps, IPreplacedwordRetriever preplacedwordRetriever) throws TransportException, FatalException, UnsupportedSecurityTypeException {
    initTunnelling(reader, writer);
    initAuthorization(reader, writer, authCaps, preplacedwordRetriever);
    return true;
}

19 Source : NoneAuthentication.java
with GNU General Public License v2.0
from Freakboy

@Override
public boolean authenticate(Reader reader, Writer writer, CapabilityContainer authCaps, IPreplacedwordRetriever preplacedwordRetriever) {
    return false;
}

19 Source : PixelFormat.java
with GNU General Public License v2.0
from Freakboy

public void fill(Reader reader) throws TransportException {
    bitsPerPixel = reader.readByte();
    depth = reader.readByte();
    bigEndianFlag = reader.readByte();
    trueColourFlag = reader.readByte();
    redMax = reader.readInt16();
    greenMax = reader.readInt16();
    blueMax = reader.readInt16();
    redShift = reader.readByte();
    greenShift = reader.readByte();
    blueShift = reader.readByte();
    // skip padding bytes
    reader.readBytes(3);
}

19 Source : ZRLEDecoder.java
with GNU General Public License v2.0
from Freakboy

@Override
public void decode(Reader reader, Renderer renderer, FramebufferUpdateRectangle rect) throws TransportException {
    int zippedLength = (int) reader.readUInt32();
    if (0 == zippedLength)
        return;
    int length = rect.width * rect.height * renderer.getBytesPerPixel();
    byte[] bytes = unzip(reader, zippedLength, length);
    int offset = zippedLength;
    int maxX = rect.x + rect.width;
    int maxY = rect.y + rect.height;
    int[] palette = new int[128];
    for (int tileY = rect.y; tileY < maxY; tileY += DEFAULT_TILE_SIZE) {
        int tileHeight = Math.min(maxY - tileY, DEFAULT_TILE_SIZE);
        for (int tileX = rect.x; tileX < maxX; tileX += DEFAULT_TILE_SIZE) {
            int tileWidth = Math.min(maxX - tileX, DEFAULT_TILE_SIZE);
            int subencoding = bytes[offset++] & 0x0ff;
            // 128 -plain RLE, 130-255 - Palette RLE
            boolean isRle = (subencoding & 128) != 0;
            // 2 to 16 for raw packed palette data, 130 to 255 for Palette RLE (subencoding - 128)
            int paletteSize = subencoding & 127;
            offset += readPalette(bytes, offset, renderer, palette, paletteSize);
            if (1 == subencoding) {
                // A solid tile consisting of a single colour
                renderer.fillRect(palette[0], tileX, tileY, tileWidth, tileHeight);
                continue;
            }
            if (isRle) {
                if (0 == paletteSize) {
                    // subencoding == 128 (or paletteSize == 0) - Plain RLE
                    offset += decodePlainRle(bytes, offset, renderer, tileX, tileY, tileWidth, tileHeight);
                } else {
                    offset += decodePaletteRle(bytes, offset, renderer, palette, tileX, tileY, tileWidth, tileHeight, paletteSize);
                }
            } else {
                if (0 == paletteSize) {
                    // subencoding == 0 (or paletteSize == 0) - raw CPIXEL data
                    offset += decodeRaw(bytes, offset, renderer, tileX, tileY, tileWidth, tileHeight);
                } else {
                    offset += decodePacked(bytes, offset, renderer, palette, paletteSize, tileX, tileY, tileWidth, tileHeight);
                }
            }
        }
    }
}

19 Source : ZlibDecoder.java
with GNU General Public License v2.0
from Freakboy

@Override
public void decode(Reader reader, Renderer renderer, FramebufferUpdateRectangle rect) throws TransportException {
    int zippedLength = (int) reader.readUInt32();
    if (0 == zippedLength)
        return;
    int length = rect.width * rect.height * renderer.getBytesPerPixel();
    byte[] bytes = unzip(reader, zippedLength, length);
    Reader unzippedReader = new Reader(new ByteArrayInputStream(bytes, zippedLength, length));
    RawDecoder.getInstance().decode(unzippedReader, renderer, rect);
}

19 Source : ZlibDecoder.java
with GNU General Public License v2.0
from Freakboy

protected byte[] unzip(Reader reader, int zippedLength, int length) throws TransportException {
    byte[] bytes = ByteBuffer.getInstance().getBuffer(zippedLength + length);
    reader.readBytes(bytes, 0, zippedLength);
    if (null == decoder) {
        decoder = new Inflater();
    }
    decoder.setInput(bytes, 0, zippedLength);
    try {
        decoder.inflate(bytes, zippedLength, length);
    } catch (DataFormatException e) {
        throw new TransportException("cannot inflate Zlib data", e);
    }
    return bytes;
}

19 Source : TightDecoder.java
with GNU General Public License v2.0
from Freakboy

/**
 * Reads compressed (expected length >= MIN_SIZE_TO_COMPRESS) or
 * uncompressed data. When compressed decompresses it.
 *
 * @param expectedLength expected data length in bytes
 * @param reader
 * @return result data
 * @throws TransportException
 */
private byte[] readTightData(int expectedLength, Reader reader) throws TransportException {
    if (expectedLength < MIN_SIZE_TO_COMPRESS) {
        byte[] buffer = ByteBuffer.getInstance().getBuffer(expectedLength);
        reader.readBytes(buffer, 0, expectedLength);
        return buffer;
    } else
        return readCompressedData(expectedLength, reader);
}

19 Source : TightDecoder.java
with GNU General Public License v2.0
from Freakboy

/**
 * Read palette from reader
 */
private int[] readPalette(int paletteSize, Reader reader, Renderer renderer) throws TransportException {
    /**
     * When bytesPerPixel == 1 && paletteSize == 2 read 2 bytes of palette
     * When bytesPerPixel == 1 && paletteSize != 2 - error
     * When bytesPerPixel == 3 (4) read (paletteSize * 3) bytes of palette
     * so use renderer.readPixelColor
     */
    int[] palette = new int[paletteSize];
    for (int i = 0; i < palette.length; ++i) {
        palette[i] = renderer.readTightPixelColor(reader);
    }
    return palette;
}

19 Source : TightDecoder.java
with GNU General Public License v2.0
from Freakboy

/**
 * Read an integer from reader in compact representation (from 1 to 3 bytes).
 * Highest bit of read byte set to 1 means next byte contains data.
 * Lower 7 bit of each byte contains significant data. Max bytes = 3.
 * Less significant bytes first order.
 *
 * @param reader
 * @return int value
 * @throws TransportException
 */
private int readCompactSize(Reader reader) throws TransportException {
    int b = reader.readUInt8();
    int size = b & 0x7F;
    if ((b & 0x80) != 0) {
        b = reader.readUInt8();
        size += (b & 0x7F) << 7;
        if ((b & 0x80) != 0) {
            size += reader.readUInt8() << 14;
        }
    }
    return size;
}

19 Source : TightDecoder.java
with GNU General Public License v2.0
from Freakboy

/**
 * Reads compressed data length, then read compressed data into rawBuffer
 * and decompress data with expected length == length
 *
 * Note: returned data contains not only decompressed data but raw data at array tail
 * which need to be ignored. Use only first expectedLength bytes.
 *
 * @param expectedLength expected data length
 * @param reader
 * @return decompressed data (length == expectedLength) / + followed raw data (ignore, please)
 * @throws TransportException
 */
private byte[] readCompressedData(int expectedLength, Reader reader) throws TransportException {
    int rawDataLength = readCompactSize(reader);
    byte[] buffer = ByteBuffer.getInstance().getBuffer(expectedLength + rawDataLength);
    // read compressed (raw) data behind space allocated for decompressed data
    reader.readBytes(buffer, expectedLength, rawDataLength);
    if (null == decoders[decoderId]) {
        decoders[decoderId] = new Inflater();
    }
    Inflater decoder = decoders[decoderId];
    decoder.setInput(buffer, expectedLength, rawDataLength);
    try {
        decoder.inflate(buffer, 0, expectedLength);
    } catch (DataFormatException e) {
        logger.throwing("TightDecoder", "readCompressedData", e);
        throw new TransportException("cannot inflate tight compressed data", e);
    }
    return buffer;
}

19 Source : TightDecoder.java
with GNU General Public License v2.0
from Freakboy

@Override
public void decode(Reader reader, Renderer renderer, FramebufferUpdateRectangle rect) throws TransportException {
    int bytesPerPixel = renderer.getBytesPerPixelSignificant();
    /**
     * bits
     * 7 - FILL or JPEG type
     * 6 - filter presence flag
     * 5, 4 - decoder to use when Basic type (bit 7 not set)
     *    or
     * 4 - JPEG type when set bit 7
     * 3 - reset decoder #3
     * 2 - reset decoder #2
     * 1 - reset decoder #1
     * 0 - reset decoder #0
     */
    int compControl = reader.readUInt8();
    resetDecoders(compControl);
    int compType = compControl >> 4 & 0x0F;
    switch(compType) {
        case FILL_TYPE:
            int color = renderer.readTightPixelColor(reader);
            renderer.fillRect(color, rect);
            break;
        case JPEG_TYPE:
            if (bytesPerPixel != 3) {
            // throw new EncodingException(
            // "Tight doesn't support JPEG subencoding while depth not equal to 24bpp is used");
            }
            processJpegType(reader, renderer, rect);
            break;
        default:
            if (compType > JPEG_TYPE) {
            // throw new EncodingException(
            // "Compression control byte is incorrect!");
            } else {
                processBasicType(compControl, reader, renderer, rect);
            }
    }
}

See More Examples