publicWagsHome
/
KasmVNC
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove old text clipboard

Browse Source
pull/69/head
Lauri Kasanen 4 years ago
parent 0824452869
commit 369bee745e
20 changed files with 8 additions and 580 deletions
Show Stats Download Patch File Download Diff File

2
common/rfb/InputHandler.h
Unescape Escape View File

@ -39,8 +39,6 @@ namespace rfb {
int __unused_attr buttonMask, int __unused_attr buttonMask,
const bool __unused_attr skipClick, const bool __unused_attr skipClick,
const bool __unused_attr skipRelease) { } const bool __unused_attr skipRelease) { }
virtual void clientCutText(const char* __unused_attr str,
int __unused_attr len) { }
}; };
} }

110
common/rfb/SConnection.cxx
Unescape Escape View File

@ -284,73 +284,6 @@ void SConnection::setEncodings(int nEncodings, const rdr::S32* encodings)
} }
SMsgHandler::setEncodings(nEncodings, encodings); SMsgHandler::setEncodings(nEncodings, encodings);
if (cp.supportsExtendedClipboard) {
rdr::U32 sizes[] = { 0 };
writer()->writeClipboardCaps(rfb::clipboardUTF8 |
rfb::clipboardRequest |
rfb::clipboardPeek |
rfb::clipboardNotify |
rfb::clipboardProvide,
sizes);
}
}
void SConnection::clientCutText(const char* str, int len)
{
hasLocalClipboard = false;
strFree(clientClipboard);
clientClipboard = NULL;
clientClipboard = latin1ToUTF8(str);
handleClipboardAnnounce(true);
}
void SConnection::handleClipboardRequest(rdr::U32 flags)
{
if (!(flags & rfb::clipboardUTF8))
return;
if (!hasLocalClipboard)
return;
handleClipboardRequest();
}
void SConnection::handleClipboardPeek(rdr::U32 flags)
{
if (!hasLocalClipboard)
return;
if (cp.clipboardFlags() & rfb::clipboardNotify)
writer()->writeClipboardNotify(rfb::clipboardUTF8);
}
void SConnection::handleClipboardNotify(rdr::U32 flags)
{
strFree(clientClipboard);
clientClipboard = NULL;
if (flags & rfb::clipboardUTF8) {
handleClipboardAnnounce(true);
hasLocalClipboard = false;
} else {
handleClipboardAnnounce(false);
}
}
void SConnection::handleClipboardProvide(rdr::U32 flags,
const size_t* lengths,
const rdr::U8* const* data)
{
if (!(flags & rfb::clipboardUTF8))
return;
strFree(clientClipboard);
clientClipboard = NULL;
clientClipboard = convertLF((const char*)data[0], lengths[0]);
handleClipboardData(clientClipboard, strlen(clientClipboard));
} }
void SConnection::clearBinaryClipboard() void SConnection::clearBinaryClipboard()
@ -464,56 +397,13 @@ void SConnection::enableContinuousUpdates(bool enable,
{ {
} }
void SConnection::handleClipboardRequest()
{
}
void SConnection::handleClipboardAnnounce(bool available) void SConnection::handleClipboardAnnounce(bool available)
{ {
} }
void SConnection::handleClipboardData(const char* data, int len)
{
}
void SConnection::requestClipboard()
{
if (clientClipboard != NULL) {
handleClipboardData(clientClipboard, strlen(clientClipboard));
return;
}
if (cp.supportsExtendedClipboard &&
(cp.clipboardFlags() & rfb::clipboardRequest))
writer()->writeClipboardRequest(rfb::clipboardUTF8);
}
void SConnection::announceClipboard(bool available) void SConnection::announceClipboard(bool available)
{ {
hasLocalClipboard = available; hasLocalClipboard = available;
if (cp.supportsExtendedClipboard &&
(cp.clipboardFlags() & rfb::clipboardNotify))
writer()->writeClipboardNotify(available ? rfb::clipboardUTF8 : 0);
else {
if (available)
handleClipboardRequest();
}
}
void SConnection::sendClipboardData(const char* data, int len)
{
if (cp.supportsExtendedClipboard &&
(cp.clipboardFlags() & rfb::clipboardProvide)) {
CharArray filtered(convertCRLF(data));
size_t sizes[1] = { strlen(filtered.buf) + 1 };
const rdr::U8* data[1] = { (const rdr::U8*)filtered.buf };
writer()->writeClipboardProvide(rfb::clipboardUTF8, sizes, data);
} else {
CharArray latin1(utf8ToLatin1(data));
writer()->writeServerCutText(latin1.buf, strlen(latin1.buf));
}
} }
void SConnection::writeFakeColourMap(void) void SConnection::writeFakeColourMap(void)

33
common/rfb/SConnection.h
Unescape Escape View File

@ -74,14 +74,6 @@ namespace rfb {
virtual void setEncodings(int nEncodings, const rdr::S32* encodings); virtual void setEncodings(int nEncodings, const rdr::S32* encodings);
virtual void clientCutText(const char* str, int len);
virtual void handleClipboardRequest(rdr::U32 flags);
virtual void handleClipboardPeek(rdr::U32 flags);
virtual void handleClipboardNotify(rdr::U32 flags);
virtual void handleClipboardProvide(rdr::U32 flags,
const size_t* lengths,
const rdr::U8* const* data);
virtual void clearBinaryClipboard(); virtual void clearBinaryClipboard();
virtual void addBinaryClipboard(const char mime[], const rdr::U8 *data, virtual void addBinaryClipboard(const char mime[], const rdr::U8 *data,
const rdr::U32 len); const rdr::U32 len);
@ -131,25 +123,11 @@ namespace rfb {
virtual void enableContinuousUpdates(bool enable, virtual void enableContinuousUpdates(bool enable,
int x, int y, int w, int h); int x, int y, int w, int h);
// handleClipboardRequest() is called whenever the client requests
// the server to send over its clipboard data. It will only be
// called after the server has first announced a clipboard change
// via announceClipboard().
virtual void handleClipboardRequest();
// handleClipboardAnnounce() is called to indicate a change in the // handleClipboardAnnounce() is called to indicate a change in the
// clipboard on the client. Call requestClipboard() to access the // clipboard on the client. Call requestClipboard() to access the
// actual data. // actual data.
virtual void handleClipboardAnnounce(bool available); virtual void handleClipboardAnnounce(bool available);
// handleClipboardData() is called when the client has sent over
// the clipboard data as a result of a previous call to
// requestClipboard(). Note that this function might never be
// called if the clipboard data was no longer available when the
// client received the request.
virtual void handleClipboardData(const char* data, int len);
virtual void add_changed_all() {} virtual void add_changed_all() {}
// setAccessRights() allows a security package to limit the access rights // setAccessRights() allows a security package to limit the access rights
@ -170,22 +148,11 @@ namespace rfb {
// Other methods // Other methods
// requestClipboard() will result in a request to the client to
// transfer its clipboard data. A call to handleClipboardData()
// will be made once the data is available.
virtual void requestClipboard();
// announceClipboard() informs the client of changes to the // announceClipboard() informs the client of changes to the
// clipboard on the server. The client may later request the // clipboard on the server. The client may later request the
// clipboard data via handleClipboardRequest(). // clipboard data via handleClipboardRequest().
virtual void announceClipboard(bool available); virtual void announceClipboard(bool available);
// sendClipboardData() transfers the clipboard data to the client
// and should be called whenever the client has requested the
// clipboard via handleClipboardRequest().
virtual void sendClipboardData(const char* data, int len);
// authenticated() returns true if the client has authenticated // authenticated() returns true if the client has authenticated
// successfully. // successfully.
bool authenticated() { return (state_ == RFBSTATE_INITIALISATION || bool authenticated() { return (state_ == RFBSTATE_INITIALISATION ||

13
common/rfb/SDesktop.h
Unescape Escape View File

@ -78,12 +78,6 @@ namespace rfb {
// the relevant RFB protocol messages from clients. // the relevant RFB protocol messages from clients.
// See InputHandler for method signatures. // See InputHandler for method signatures.
// handleClipboardRequest() is called whenever a client requests
// the server to send over its clipboard data. It will only be
// called after the server has first announced a clipboard change
// via VNCServer::announceClipboard().
virtual void handleClipboardRequest() {}
// handleClipboardAnnounce() is called to indicate a change in the // handleClipboardAnnounce() is called to indicate a change in the
// clipboard on a client. Call VNCServer::requestClipboard() to // clipboard on a client. Call VNCServer::requestClipboard() to
// access the actual data. // access the actual data.
@ -92,13 +86,6 @@ namespace rfb {
virtual void handleClipboardAnnounceBinary(const unsigned __unused_attr num, virtual void handleClipboardAnnounceBinary(const unsigned __unused_attr num,
const char __unused_attr mimes[][32]) {} const char __unused_attr mimes[][32]) {}
// handleClipboardData() is called when a client has sent over
// the clipboard data as a result of a previous call to
// VNCServer::requestClipboard(). Note that this function might
// never be called if the clipboard data was no longer available
// when the client received the request.
virtual void handleClipboardData(const char* __unused_attr data, int len __unused_attr) {}
protected: protected:
virtual ~SDesktop() {} virtual ~SDesktop() {}
}; };

23
common/rfb/SMsgHandler.cxx
Unescape Escape View File

@ -64,33 +64,10 @@ void SMsgHandler::setEncodings(int nEncodings, const rdr::S32* encodings)
supportsQEMUKeyEvent(); supportsQEMUKeyEvent();
} }
void SMsgHandler::handleClipboardCaps(rdr::U32 flags, const rdr::U32* lengths)
{
cp.setClipboardCaps(flags, lengths);
}
void SMsgHandler::handleClipboardAnnounceBinary(const unsigned, const char mimes[][32]) void SMsgHandler::handleClipboardAnnounceBinary(const unsigned, const char mimes[][32])
{ {
} }
void SMsgHandler::handleClipboardRequest(rdr::U32 flags)
{
}
void SMsgHandler::handleClipboardPeek(rdr::U32 flags)
{
}
void SMsgHandler::handleClipboardNotify(rdr::U32 flags)
{
}
void SMsgHandler::handleClipboardProvide(rdr::U32 flags,
const size_t* lengths,
const rdr::U8* const* data)
{
}
void SMsgHandler::clearBinaryClipboard() void SMsgHandler::clearBinaryClipboard()
{ {
} }

8
common/rfb/SMsgHandler.h
Unescape Escape View File

@ -55,14 +55,6 @@ namespace rfb {
int x, int y, int w, int h) = 0; int x, int y, int w, int h) = 0;
virtual void handleClipboardAnnounceBinary(const unsigned num, const char mimes[][32]); virtual void handleClipboardAnnounceBinary(const unsigned num, const char mimes[][32]);
virtual void handleClipboardCaps(rdr::U32 flags,
const rdr::U32* lengths);
virtual void handleClipboardRequest(rdr::U32 flags);
virtual void handleClipboardPeek(rdr::U32 flags);
virtual void handleClipboardNotify(rdr::U32 flags);
virtual void handleClipboardProvide(rdr::U32 flags,
const size_t* lengths,
const rdr::U8* const* data);
virtual void clearBinaryClipboard(); virtual void clearBinaryClipboard();
virtual void addBinaryClipboard(const char mime[], const rdr::U8 *data, virtual void addBinaryClipboard(const char mime[], const rdr::U8 *data,
const rdr::U32 len); const rdr::U32 len);

103
common/rfb/SMsgReader.cxx
Unescape Escape View File

@ -35,8 +35,6 @@ using namespace rfb;
static LogWriter vlog("SMsgReader"); static LogWriter vlog("SMsgReader");
static IntParameter maxCutText("MaxCutText", "Maximum permitted length of an incoming clipboard update", 256*1024);
SMsgReader::SMsgReader(SMsgHandler* handler_, rdr::InStream* is_) SMsgReader::SMsgReader(SMsgHandler* handler_, rdr::InStream* is_)
: handler(handler_), is(is_) : handler(handler_), is(is_)
{ {
@ -241,15 +239,8 @@ void SMsgReader::readClientCutText()
readExtendedClipboard(slen); readExtendedClipboard(slen);
return; return;
} }
if (len > (size_t)maxCutText) { is->skip(len);
is->skip(len); vlog.error("Client sent old cuttext msg, ignoring");
vlog.error("Cut text too long (%d bytes) - ignoring", len);
return;
}
CharArray ca(len+1);
ca.buf[len] = 0;
is->readBytes(ca.buf, len);
handler->clientCutText(ca.buf, len);
} }
void SMsgReader::readBinaryClipboard() void SMsgReader::readBinaryClipboard()
@ -292,96 +283,10 @@ void SMsgReader::readBinaryClipboard()
void SMsgReader::readExtendedClipboard(rdr::S32 len) void SMsgReader::readExtendedClipboard(rdr::S32 len)
{ {
rdr::U32 flags;
rdr::U32 action;
if (len < 4) if (len < 4)
throw Exception("Invalid extended clipboard message"); throw Exception("Invalid extended clipboard message");
if (len > maxCutText) { vlog.error("Client sent old cuttext msg, ignoring");
vlog.error("Extended clipboard message too long (%d bytes) - ignoring", len); is->skip(len);
is->skip(len);
return;
}
flags = is->readU32();
action = flags & clipboardActionMask;
if (action & clipboardCaps) {
int i;
size_t num;
rdr::U32 lengths[16];
num = 0;
for (i = 0;i < 16;i++) {
if (flags & (1 << i))
num++;
}
if (len < (rdr::S32)(4 + 4*num))
throw Exception("Invalid extended clipboard message");
num = 0;
for (i = 0;i < 16;i++) {
if (flags & (1 << i))
lengths[num++] = is->readU32();
}
handler->handleClipboardCaps(flags, lengths);
} else if (action == clipboardProvide) {
rdr::ZlibInStream zis;
int i;
size_t num;
size_t lengths[16];
rdr::U8* buffers[16];
zis.setUnderlying(is, len - 4);
num = 0;
for (i = 0;i < 16;i++) {
if (!(flags & 1 << i))
continue;
lengths[num] = zis.readU32();
if (lengths[num] > (size_t)maxCutText) {
vlog.error("Extended clipboard data too long (%d bytes) - ignoring",
(unsigned)lengths[num]);
zis.skip(lengths[num]);
flags &= ~(1 << i);
continue;
}
buffers[num] = new rdr::U8[lengths[num]];
zis.readBytes(buffers[num], lengths[num]);
num++;
}
zis.flushUnderlying();
zis.setUnderlying(NULL, 0);
handler->handleClipboardProvide(flags, lengths, buffers);
num = 0;
for (i = 0;i < 16;i++) {
if (!(flags & 1 << i))
continue;
delete [] buffers[num++];
}
} else {
switch (action) {
case clipboardRequest:
handler->handleClipboardRequest(flags);
break;
case clipboardPeek:
handler->handleClipboardPeek(flags);
break;
case clipboardNotify:
handler->handleClipboardNotify(flags);
break;
default:
throw Exception("Invalid extended clipboard action");
}
}
} }
void SMsgReader::readRequestStats() void SMsgReader::readRequestStats()

115
common/rfb/SMsgWriter.cxx
Unescape Escape View File

@ -85,121 +85,6 @@ void SMsgWriter::writeBell()
endMsg(); endMsg();
} }
void SMsgWriter::writeServerCutText(const char* str, int len)
{
startMsg(msgTypeServerCutText);
os->pad(3);
os->writeU32(len);
os->writeBytes(str, len);
endMsg();
}
void SMsgWriter::writeClipboardCaps(rdr::U32 caps,
const rdr::U32* lengths)
{
size_t i, count;
if (!cp->supportsExtendedClipboard)
throw Exception("Client does not support extended clipboard");
count = 0;
for (i = 0;i < 16;i++) {
if (caps & (1 << i))
count++;
}
startMsg(msgTypeServerCutText);
os->pad(3);
os->writeS32(-(4 + 4 * count));
os->writeU32(caps | clipboardCaps);
count = 0;
for (i = 0;i < 16;i++) {
if (caps & (1 << i))
os->writeU32(lengths[count++]);
}
endMsg();
}
void SMsgWriter::writeClipboardRequest(rdr::U32 flags)
{
if (!cp->supportsExtendedClipboard)
throw Exception("Client does not support extended clipboard");
if (!(cp->clipboardFlags() & clipboardRequest))
throw Exception("Client does not support clipboard \"request\" action");
startMsg(msgTypeServerCutText);
os->pad(3);
os->writeS32(-4);
os->writeU32(flags | clipboardRequest);
endMsg();
}
void SMsgWriter::writeClipboardPeek(rdr::U32 flags)
{
if (!cp->supportsExtendedClipboard)
throw Exception("Client does not support extended clipboard");
if (!(cp->clipboardFlags() & clipboardPeek))
throw Exception("Client does not support clipboard \"peek\" action");
startMsg(msgTypeServerCutText);
os->pad(3);
os->writeS32(-4);
os->writeU32(flags | clipboardPeek);
endMsg();
}
void SMsgWriter::writeClipboardNotify(rdr::U32 flags)
{
if (!cp->supportsExtendedClipboard)
throw Exception("Client does not support extended clipboard");
if (!(cp->clipboardFlags() & clipboardNotify))
throw Exception("Client does not support clipboard \"notify\" action");
startMsg(msgTypeServerCutText);
os->pad(3);
os->writeS32(-4);
os->writeU32(flags | clipboardNotify);
endMsg();
}
void SMsgWriter::writeClipboardProvide(rdr::U32 flags,
const size_t* lengths,
const rdr::U8* const* data)
{
rdr::MemOutStream mos;
rdr::ZlibOutStream zos;
int i, count;
if (!cp->supportsExtendedClipboard)
throw Exception("Client does not support extended clipboard");
if (!(cp->clipboardFlags() & clipboardProvide))
throw Exception("Client does not support clipboard \"provide\" action");
zos.setUnderlying(&mos);
count = 0;
for (i = 0;i < 16;i++) {
if (!(flags & (1 << i)))
continue;
zos.writeU32(lengths[count]);
zos.writeBytes(data[count], lengths[count]);
count++;
}
zos.flush();
startMsg(msgTypeServerCutText);
os->pad(3);
os->writeS32(-(4 + mos.length()));
os->writeU32(flags | clipboardProvide);
os->writeBytes(mos.data(), mos.length());
endMsg();
}
void SMsgWriter::writeBinaryClipboard(const std::vector<SConnection::binaryClipboard_t> &b) void SMsgWriter::writeBinaryClipboard(const std::vector<SConnection::binaryClipboard_t> &b)
{ {
startMsg(msgTypeBinaryClipboard); startMsg(msgTypeBinaryClipboard);

9
common/rfb/SMsgWriter.h
Unescape Escape View File

@ -56,14 +56,7 @@ namespace rfb {
// writeBell() and writeServerCutText() do the obvious thing. // writeBell() and writeServerCutText() do the obvious thing.
void writeBell(); void writeBell();
void writeServerCutText(const char* str, int len);
void writeClipboardCaps(rdr::U32 caps, const rdr::U32* lengths);
void writeClipboardRequest(rdr::U32 flags);
void writeClipboardPeek(rdr::U32 flags);
void writeClipboardNotify(rdr::U32 flags);
void writeClipboardProvide(rdr::U32 flags, const size_t* lengths,
const rdr::U8* const* data);
void writeBinaryClipboard(const std::vector<SConnection::binaryClipboard_t> &b); void writeBinaryClipboard(const std::vector<SConnection::binaryClipboard_t> &b);
void writeStats(const char* str, int len); void writeStats(const char* str, int len);

60
common/rfb/VNCSConnectionST.cxx
Unescape Escape View File

@ -414,18 +414,6 @@ static void keylog(unsigned keysym, const char *client) {
flushKeylog(client); flushKeylog(client);
} }
void VNCSConnectionST::requestClipboardOrClose()
{
try {
if (!(accessRights & AccessCutText)) return;
if (!rfb::Server::acceptCutText) return;
if (state() != RFBSTATE_NORMAL) return;
requestClipboard();
} catch(rdr::Exception& e) {
close(e.str());
}
}
void VNCSConnectionST::announceClipboardOrClose(bool available) void VNCSConnectionST::announceClipboardOrClose(bool available)
{ {
try { try {
@ -438,29 +426,6 @@ void VNCSConnectionST::announceClipboardOrClose(bool available)
} }
} }
void VNCSConnectionST::sendClipboardDataOrClose(const char* data)
{
try {
if (!(accessRights & AccessCutText)) return;
if (!rfb::Server::sendCutText) return;
if (msSince(&lastClipboardOp) < (unsigned) rfb::Server::DLP_ClipDelay) {
vlog.info("DLP: client %s: refused to send clipboard, too soon",
sock->getPeerAddress());
return;
}
int len = strlen(data);
const int origlen = len;
if (rfb::Server::DLP_ClipSendMax && len > rfb::Server::DLP_ClipSendMax)
len = rfb::Server::DLP_ClipSendMax;
cliplog(data, len, origlen, "sent", sock->getPeerAddress());
if (state() != RFBSTATE_NORMAL) return;
sendClipboardData(data, len);
gettimeofday(&lastClipboardOp, NULL);
} catch(rdr::Exception& e) {
close(e.str());
}
}
void VNCSConnectionST::clearBinaryClipboardData() void VNCSConnectionST::clearBinaryClipboardData()
{ {
clearBinaryClipboard(); clearBinaryClipboard();
@ -1067,12 +1032,6 @@ void VNCSConnectionST::enableContinuousUpdates(bool enable,
} }
} }
void VNCSConnectionST::handleClipboardRequest()
{
if (!(accessRights & AccessCutText)) return;
server->handleClipboardRequest(this);
}
void VNCSConnectionST::handleClipboardAnnounce(bool available) void VNCSConnectionST::handleClipboardAnnounce(bool available)
{ {
if (!(accessRights & AccessCutText)) return; if (!(accessRights & AccessCutText)) return;
@ -1087,25 +1046,6 @@ void VNCSConnectionST::handleClipboardAnnounceBinary(const unsigned num, const c
server->handleClipboardAnnounceBinary(this, num, mimes); server->handleClipboardAnnounceBinary(this, num, mimes);
} }
void VNCSConnectionST::handleClipboardData(const char* data, int len)
{
if (!(accessRights & AccessCutText)) return;
if (!rfb::Server::acceptCutText) return;
if (msSince(&lastClipboardOp) < (unsigned) rfb::Server::DLP_ClipDelay) {
vlog.info("DLP: client %s: refused to receive clipboard, too soon",
sock->getPeerAddress());
return;
}
const int origlen = len;
if (rfb::Server::DLP_ClipAcceptMax && len > rfb::Server::DLP_ClipAcceptMax)
len = rfb::Server::DLP_ClipAcceptMax;
cliplog(data, len, origlen, "received", sock->getPeerAddress());
gettimeofday(&lastClipboardOp, NULL);
server->handleClipboardData(this, data, len);
}
// supportsLocalCursor() is called whenever the status of // supportsLocalCursor() is called whenever the status of
// cp.supportsLocalCursor has changed. If the client does now support local // cp.supportsLocalCursor has changed. If the client does now support local
// cursor, we make sure that the old server-side rendered cursor is cleaned up // cursor, we make sure that the old server-side rendered cursor is cleaned up

4
common/rfb/VNCSConnectionST.h
Unescape Escape View File

@ -77,9 +77,7 @@ namespace rfb {
void bellOrClose(); void bellOrClose();
void setDesktopNameOrClose(const char *name); void setDesktopNameOrClose(const char *name);
void setLEDStateOrClose(unsigned int state); void setLEDStateOrClose(unsigned int state);
void requestClipboardOrClose();
void announceClipboardOrClose(bool available); void announceClipboardOrClose(bool available);
void sendClipboardDataOrClose(const char* data);
void clearBinaryClipboardData(); void clearBinaryClipboardData();
void sendBinaryClipboardDataOrClose(const char* mime, const unsigned char *data, void sendBinaryClipboardDataOrClose(const char* mime, const unsigned char *data,
const unsigned len); const unsigned len);
@ -217,10 +215,8 @@ namespace rfb {
virtual void fence(rdr::U32 flags, unsigned len, const char data[]); virtual void fence(rdr::U32 flags, unsigned len, const char data[]);
virtual void enableContinuousUpdates(bool enable, virtual void enableContinuousUpdates(bool enable,
int x, int y, int w, int h); int x, int y, int w, int h);
virtual void handleClipboardRequest();
virtual void handleClipboardAnnounce(bool available); virtual void handleClipboardAnnounce(bool available);
virtual void handleClipboardAnnounceBinary(const unsigned num, const char mimes[][32]); virtual void handleClipboardAnnounceBinary(const unsigned num, const char mimes[][32]);
virtual void handleClipboardData(const char* data, int len);
virtual void supportsLocalCursor(); virtual void supportsLocalCursor();
virtual void supportsFence(); virtual void supportsFence();
virtual void supportsContinuousUpdates(); virtual void supportsContinuousUpdates();

11
common/rfb/VNCServer.h
Unescape Escape View File

@ -52,22 +52,11 @@ namespace rfb {
// getPixelBuffer() returns a pointer to the PixelBuffer object. // getPixelBuffer() returns a pointer to the PixelBuffer object.
virtual PixelBuffer* getPixelBuffer() const = 0; virtual PixelBuffer* getPixelBuffer() const = 0;
// requestClipboard() will result in a request to a client to
// transfer its clipboard data. A call to
// SDesktop::handleClipboardData() will be made once the data is
// available.
virtual void requestClipboard() = 0;
// announceClipboard() informs all clients of changes to the // announceClipboard() informs all clients of changes to the
// clipboard on the server. A client may later request the // clipboard on the server. A client may later request the
// clipboard data via SDesktop::handleClipboardRequest(). // clipboard data via SDesktop::handleClipboardRequest().
virtual void announceClipboard(bool available) = 0; virtual void announceClipboard(bool available) = 0;
// sendClipboardData() transfers the clipboard data to a client
// and should be called whenever a client has requested the
// clipboard via SDesktop::handleClipboardRequest().
virtual void sendClipboardData(const char* data) = 0;
// bell() tells the server that it should make all clients make a bell sound. // bell() tells the server that it should make all clients make a bell sound.
virtual void bell() = 0; virtual void bell() = 0;

40
common/rfb/VNCServerST.cxx
Unescape Escape View File

@ -518,14 +518,6 @@ void VNCServerST::setScreenLayout(const ScreenSet& layout)
} }
} }
void VNCServerST::requestClipboard()
{
if (clipboardClient == NULL)
return;
clipboardClient->requestClipboard();
}
void VNCServerST::announceClipboard(bool available) void VNCServerST::announceClipboard(bool available)
{ {
std::list<VNCSConnectionST*>::iterator ci, ci_next; std::list<VNCSConnectionST*>::iterator ci, ci_next;
@ -541,22 +533,6 @@ void VNCServerST::announceClipboard(bool available)
} }
} }
void VNCServerST::sendClipboardData(const char* data)
{
std::list<VNCSConnectionST*>::iterator ci, ci_next;
if (strchr(data, '\r') != NULL)
throw Exception("Invalid carriage return in clipboard data");
for (ci = clipboardRequestors.begin();
ci != clipboardRequestors.end(); ci = ci_next) {
ci_next = ci; ci_next++;
(*ci)->sendClipboardDataOrClose(data);
}
clipboardRequestors.clear();
}
void VNCServerST::sendBinaryClipboardData(const char* mime, const unsigned char *data, void VNCServerST::sendBinaryClipboardData(const char* mime, const unsigned char *data,
const unsigned len) const unsigned len)
{ {
@ -1225,13 +1201,6 @@ bool VNCServerST::getComparerState()
return false; return false;
} }
void VNCServerST::handleClipboardRequest(VNCSConnectionST* client)
{
clipboardRequestors.push_back(client);
if (clipboardRequestors.size() == 1)
desktop->handleClipboardRequest();
}
void VNCServerST::handleClipboardAnnounce(VNCSConnectionST* client, void VNCServerST::handleClipboardAnnounce(VNCSConnectionST* client,
bool available) bool available)
{ {
@ -1252,12 +1221,3 @@ void VNCServerST::handleClipboardAnnounceBinary(VNCSConnectionST* client,
clipboardClient = client; clipboardClient = client;
desktop->handleClipboardAnnounceBinary(num, mimes); desktop->handleClipboardAnnounceBinary(num, mimes);
} }
void VNCServerST::handleClipboardData(VNCSConnectionST* client,
const char* data, int len)
{
if (client != clipboardClient)
return;
desktop->handleClipboardData(data, len);
}

4
common/rfb/VNCServerST.h
Unescape Escape View File

@ -96,9 +96,7 @@ namespace rfb {
virtual void setPixelBuffer(PixelBuffer* pb); virtual void setPixelBuffer(PixelBuffer* pb);
virtual void setScreenLayout(const ScreenSet& layout); virtual void setScreenLayout(const ScreenSet& layout);
virtual PixelBuffer* getPixelBuffer() const { if (DLPRegion.enabled && blackedpb) return blackedpb; else return pb; } virtual PixelBuffer* getPixelBuffer() const { if (DLPRegion.enabled && blackedpb) return blackedpb; else return pb; }
virtual void requestClipboard();
virtual void announceClipboard(bool available); virtual void announceClipboard(bool available);
virtual void sendClipboardData(const char* data);
virtual void clearBinaryClipboardData(); virtual void clearBinaryClipboardData();
virtual void sendBinaryClipboardData(const char* mime, const unsigned char *data, virtual void sendBinaryClipboardData(const char* mime, const unsigned char *data,
const unsigned len); const unsigned len);
@ -196,11 +194,9 @@ namespace rfb {
void setAPIMessager(network::GetAPIMessager *msgr) { apimessager = msgr; } void setAPIMessager(network::GetAPIMessager *msgr) { apimessager = msgr; }
void handleClipboardRequest(VNCSConnectionST* client);
void handleClipboardAnnounce(VNCSConnectionST* client, bool available); void handleClipboardAnnounce(VNCSConnectionST* client, bool available);
void handleClipboardAnnounceBinary(VNCSConnectionST* client, const unsigned num, void handleClipboardAnnounceBinary(VNCSConnectionST* client, const unsigned num,
const char mimes[][32]); const char mimes[][32]);
void handleClipboardData(VNCSConnectionST* client, const char* data, int len);
protected: protected:

28
unix/xserver/hw/vnc/XserverDesktop.cc
Unescape Escape View File

@ -176,15 +176,6 @@ XserverDesktop::queryConnection(network::Socket* sock,
return rfb::VNCServerST::PENDING; return rfb::VNCServerST::PENDING;
} }
void XserverDesktop::requestClipboard()
{
try {
server->requestClipboard();
} catch (rdr::Exception& e) {
vlog.error("XserverDesktop::requestClipboard: %s",e.str());
}
}
void XserverDesktop::announceClipboard(bool available) void XserverDesktop::announceClipboard(bool available)
{ {
try { try {
@ -194,15 +185,6 @@ void XserverDesktop::announceClipboard(bool available)
} }
} }
void XserverDesktop::sendClipboardData(const char* data)
{
try {
server->sendClipboardData(data);
} catch (rdr::Exception& e) {
vlog.error("XserverDesktop::sendClipboardData: %s",e.str());
}
}
void XserverDesktop::clearBinaryClipboardData() void XserverDesktop::clearBinaryClipboardData()
{ {
try { try {
@ -500,11 +482,6 @@ unsigned int XserverDesktop::setScreenLayout(int fb_width, int fb_height,
return ret; return ret;
} }
void XserverDesktop::handleClipboardRequest()
{
vncHandleClipboardRequest();
}
void XserverDesktop::handleClipboardAnnounce(bool available) void XserverDesktop::handleClipboardAnnounce(bool available)
{ {
vncHandleClipboardAnnounce(available); vncHandleClipboardAnnounce(available);
@ -515,11 +492,6 @@ void XserverDesktop::handleClipboardAnnounceBinary(const unsigned num, const cha
vncHandleClipboardAnnounceBinary(num, mimes); vncHandleClipboardAnnounceBinary(num, mimes);
} }
void XserverDesktop::handleClipboardData(const char* data_, int len)
{
vncHandleClipboardData(data_, len);
}
void XserverDesktop::grabRegion(const rfb::Region& region) void XserverDesktop::grabRegion(const rfb::Region& region)
{ {
if (directFbptr) if (directFbptr)

3
unix/xserver/hw/vnc/XserverDesktop.h
Unescape Escape View File

@ -62,7 +62,6 @@ public:
void refreshScreenLayout(); void refreshScreenLayout();
void requestClipboard(); void requestClipboard();
void announceClipboard(bool available); void announceClipboard(bool available);
void sendClipboardData(const char* data);
void clearBinaryClipboardData(); void clearBinaryClipboardData();
void sendBinaryClipboardData(const char* mime, const unsigned char *data, void sendBinaryClipboardData(const char* mime, const unsigned char *data,
const unsigned len); const unsigned len);
@ -99,10 +98,8 @@ public:
virtual void keyEvent(rdr::U32 keysym, rdr::U32 keycode, bool down); virtual void keyEvent(rdr::U32 keysym, rdr::U32 keycode, bool down);
virtual unsigned int setScreenLayout(int fb_width, int fb_height, virtual unsigned int setScreenLayout(int fb_width, int fb_height,
const rfb::ScreenSet& layout); const rfb::ScreenSet& layout);
virtual void handleClipboardRequest();
virtual void handleClipboardAnnounce(bool available); virtual void handleClipboardAnnounce(bool available);
virtual void handleClipboardAnnounceBinary(const unsigned num, const char mimes[][32]); virtual void handleClipboardAnnounceBinary(const unsigned num, const char mimes[][32]);
virtual void handleClipboardData(const char* data, int len);
// rfb::PixelBuffer callbacks // rfb::PixelBuffer callbacks
virtual void grabRegion(const rfb::Region& r); virtual void grabRegion(const rfb::Region& r);

12
unix/xserver/hw/vnc/vncExtInit.cc
Unescape Escape View File

@ -352,24 +352,12 @@ void vncUpdateDesktopName(void)
desktop[scr]->setDesktopName(desktopName); desktop[scr]->setDesktopName(desktopName);
} }
void vncRequestClipboard(void)
{
for (int scr = 0; scr < vncGetScreenCount(); scr++)
desktop[scr]->requestClipboard();
}
void vncAnnounceClipboard(int available) void vncAnnounceClipboard(int available)
{ {
for (int scr = 0; scr < vncGetScreenCount(); scr++) for (int scr = 0; scr < vncGetScreenCount(); scr++)
desktop[scr]->announceClipboard(available); desktop[scr]->announceClipboard(available);
} }
void vncSendClipboardData(const char* data)
{
for (int scr = 0; scr < vncGetScreenCount(); scr++)
desktop[scr]->sendClipboardData(data);
}
void vncSendBinaryClipboardData(const char* mime, const unsigned char *data, void vncSendBinaryClipboardData(const char* mime, const unsigned char *data,
const unsigned len) const unsigned len)
{ {

2
unix/xserver/hw/vnc/vncExtInit.h
Unescape Escape View File

@ -67,9 +67,7 @@ int vncGetSendPrimary(void);
void vncUpdateDesktopName(void); void vncUpdateDesktopName(void);
void vncRequestClipboard(void);
void vncAnnounceClipboard(int available); void vncAnnounceClipboard(int available);
void vncSendClipboardData(const char* data);
void vncClearBinaryClipboardData(); void vncClearBinaryClipboardData();
void vncSendBinaryClipboardData(const char* mime, const unsigned char *data, void vncSendBinaryClipboardData(const char* mime, const unsigned char *data,
const unsigned len); const unsigned len);

6
unix/xserver/hw/vnc/vncSelection.c
Unescape Escape View File

@ -477,7 +477,7 @@ static int vncConvertSelection(ClientPtr client, Atom selection,
LOG_DEBUG("Requesting clipboard data from client"); LOG_DEBUG("Requesting clipboard data from client");
vncRequestClipboard(); //vncRequestClipboard();
return Success; return Success;
} else { } else {
@ -700,7 +700,7 @@ static void vncHandleSelection(Atom selection, Atom target,
LOG_DEBUG("Sending clipboard to clients (%d bytes)", LOG_DEBUG("Sending clipboard to clients (%d bytes)",
(int)strlen(utf8)); (int)strlen(utf8));
vncSendClipboardData(utf8); //vncSendClipboardData(utf8);
vncStrFree(utf8); vncStrFree(utf8);
} else if (target == xaUTF8_STRING) { } else if (target == xaUTF8_STRING) {
@ -718,7 +718,7 @@ static void vncHandleSelection(Atom selection, Atom target,
LOG_DEBUG("Sending clipboard to clients (%d bytes)", LOG_DEBUG("Sending clipboard to clients (%d bytes)",
(int)strlen(filtered)); (int)strlen(filtered));
vncSendClipboardData(filtered); //vncSendClipboardData(filtered);
vncStrFree(filtered); vncStrFree(filtered);
} else { } else {

2
unix/xserver/hw/vnc/vncSelection.h
Unescape Escape View File

@ -24,10 +24,8 @@ extern "C" {
void vncSelectionInit(void); void vncSelectionInit(void);
void vncHandleClipboardRequest(void);
void vncHandleClipboardAnnounce(int available); void vncHandleClipboardAnnounce(int available);
void vncHandleClipboardAnnounceBinary(const unsigned num, const char mimes[][32]); void vncHandleClipboardAnnounceBinary(const unsigned num, const char mimes[][32]);
void vncHandleClipboardData(const char* data, int len);
#ifdef __cplusplus #ifdef __cplusplus
} }

Write Preview
Loading…
Cancel
Save