diff --git a/common/rfb/InputHandler.h b/common/rfb/InputHandler.h
index 806625f..961e3d7 100644
--- a/common/rfb/InputHandler.h
+++ b/common/rfb/InputHandler.h
@@ -39,8 +39,6 @@ namespace rfb {
 		              int __unused_attr buttonMask,
                               const bool __unused_attr skipClick,
                               const bool __unused_attr skipRelease) { }
-    virtual void clientCutText(const char* __unused_attr str,
-                               int __unused_attr len) { }
   };
 
 }
diff --git a/common/rfb/SConnection.cxx b/common/rfb/SConnection.cxx
index 15b22d2..5567a96 100644
--- a/common/rfb/SConnection.cxx
+++ b/common/rfb/SConnection.cxx
@@ -284,73 +284,6 @@ void SConnection::setEncodings(int nEncodings, const rdr::S32* 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()
@@ -464,56 +397,13 @@ void SConnection::enableContinuousUpdates(bool enable,
 {
 }
 
-void SConnection::handleClipboardRequest()
-{
-}
-
 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)
 {
   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)
diff --git a/common/rfb/SConnection.h b/common/rfb/SConnection.h
index 68b50c7..8b5b3de 100644
--- a/common/rfb/SConnection.h
+++ b/common/rfb/SConnection.h
@@ -74,14 +74,6 @@ namespace rfb {
 
     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 addBinaryClipboard(const char mime[], const rdr::U8 *data,
                                     const rdr::U32 len);
@@ -131,25 +123,11 @@ namespace rfb {
     virtual void enableContinuousUpdates(bool enable,
                                          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
     // clipboard on the client. Call requestClipboard() to access the
     // actual data.
     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() {}
 
     // setAccessRights() allows a security package to limit the access rights
@@ -170,22 +148,11 @@ namespace rfb {
 
     // 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
     // clipboard on the server. The client may later request the
     // clipboard data via handleClipboardRequest().
     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
     // successfully.
     bool authenticated() { return (state_ == RFBSTATE_INITIALISATION ||
diff --git a/common/rfb/SDesktop.h b/common/rfb/SDesktop.h
index c06ae0b..5696cfd 100644
--- a/common/rfb/SDesktop.h
+++ b/common/rfb/SDesktop.h
@@ -78,12 +78,6 @@ namespace rfb {
     // the relevant RFB protocol messages from clients.
     // 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
     // clipboard on a client. Call VNCServer::requestClipboard() to
     // access the actual data.
@@ -92,13 +86,6 @@ namespace rfb {
     virtual void handleClipboardAnnounceBinary(const unsigned __unused_attr num,
                                                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:
     virtual ~SDesktop() {}
   };
diff --git a/common/rfb/SMsgHandler.cxx b/common/rfb/SMsgHandler.cxx
index 74bd194..07499bc 100644
--- a/common/rfb/SMsgHandler.cxx
+++ b/common/rfb/SMsgHandler.cxx
@@ -64,33 +64,10 @@ void SMsgHandler::setEncodings(int nEncodings, const rdr::S32* encodings)
     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::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()
 {
 }
diff --git a/common/rfb/SMsgHandler.h b/common/rfb/SMsgHandler.h
index 8d29b50..d9d852a 100644
--- a/common/rfb/SMsgHandler.h
+++ b/common/rfb/SMsgHandler.h
@@ -55,14 +55,6 @@ namespace rfb {
                                          int x, int y, int w, int h) = 0;
 
     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 addBinaryClipboard(const char mime[], const rdr::U8 *data,
                                     const rdr::U32 len);
diff --git a/common/rfb/SMsgReader.cxx b/common/rfb/SMsgReader.cxx
index 84f9b5b..b256996 100644
--- a/common/rfb/SMsgReader.cxx
+++ b/common/rfb/SMsgReader.cxx
@@ -35,8 +35,6 @@ using namespace rfb;
 
 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_)
   : handler(handler_), is(is_)
 {
@@ -241,15 +239,8 @@ void SMsgReader::readClientCutText()
     readExtendedClipboard(slen);
     return;
   }
-  if (len > (size_t)maxCutText) {
-    is->skip(len);
-    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);
+  is->skip(len);
+  vlog.error("Client sent old cuttext msg, ignoring");
 }
 
 void SMsgReader::readBinaryClipboard()
@@ -292,96 +283,10 @@ void SMsgReader::readBinaryClipboard()
 
 void SMsgReader::readExtendedClipboard(rdr::S32 len)
 {
-  rdr::U32 flags;
-  rdr::U32 action;
-
   if (len < 4)
     throw Exception("Invalid extended clipboard message");
-  if (len > maxCutText) {
-    vlog.error("Extended clipboard message too long (%d bytes) - ignoring", 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");
-    }
-  }
+  vlog.error("Client sent old cuttext msg, ignoring");
+  is->skip(len);
 }
 
 void SMsgReader::readRequestStats()
diff --git a/common/rfb/SMsgWriter.cxx b/common/rfb/SMsgWriter.cxx
index 8127716..a0a9df0 100644
--- a/common/rfb/SMsgWriter.cxx
+++ b/common/rfb/SMsgWriter.cxx
@@ -85,121 +85,6 @@ void SMsgWriter::writeBell()
   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)
 {
   startMsg(msgTypeBinaryClipboard);
diff --git a/common/rfb/SMsgWriter.h b/common/rfb/SMsgWriter.h
index e28f0e1..c72012e 100644
--- a/common/rfb/SMsgWriter.h
+++ b/common/rfb/SMsgWriter.h
@@ -56,14 +56,7 @@ namespace rfb {
 
     // writeBell() and writeServerCutText() do the obvious thing.
     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 writeStats(const char* str, int len);
diff --git a/common/rfb/VNCSConnectionST.cxx b/common/rfb/VNCSConnectionST.cxx
index 354697d..55103e2 100644
--- a/common/rfb/VNCSConnectionST.cxx
+++ b/common/rfb/VNCSConnectionST.cxx
@@ -414,18 +414,6 @@ static void keylog(unsigned keysym, const char *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)
 {
   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()
 {
   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)
 {
   if (!(accessRights & AccessCutText)) return;
@@ -1087,25 +1046,6 @@ void VNCSConnectionST::handleClipboardAnnounceBinary(const unsigned num, const c
   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
 // 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
diff --git a/common/rfb/VNCSConnectionST.h b/common/rfb/VNCSConnectionST.h
index 76a0911..eb9861a 100644
--- a/common/rfb/VNCSConnectionST.h
+++ b/common/rfb/VNCSConnectionST.h
@@ -77,9 +77,7 @@ namespace rfb {
     void bellOrClose();
     void setDesktopNameOrClose(const char *name);
     void setLEDStateOrClose(unsigned int state);
-    void requestClipboardOrClose();
     void announceClipboardOrClose(bool available);
-    void sendClipboardDataOrClose(const char* data);
     void clearBinaryClipboardData();
     void sendBinaryClipboardDataOrClose(const char* mime, const unsigned char *data,
                                         const unsigned len);
@@ -217,10 +215,8 @@ namespace rfb {
     virtual void fence(rdr::U32 flags, unsigned len, const char data[]);
     virtual void enableContinuousUpdates(bool enable,
                                          int x, int y, int w, int h);
-    virtual void handleClipboardRequest();
     virtual void handleClipboardAnnounce(bool available);
     virtual void handleClipboardAnnounceBinary(const unsigned num, const char mimes[][32]);
-    virtual void handleClipboardData(const char* data, int len);
     virtual void supportsLocalCursor();
     virtual void supportsFence();
     virtual void supportsContinuousUpdates();
diff --git a/common/rfb/VNCServer.h b/common/rfb/VNCServer.h
index 54e3504..33b0533 100644
--- a/common/rfb/VNCServer.h
+++ b/common/rfb/VNCServer.h
@@ -52,22 +52,11 @@ namespace rfb {
     // getPixelBuffer() returns a pointer to the PixelBuffer object.
     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
     // clipboard on the server. A client may later request the
     // clipboard data via SDesktop::handleClipboardRequest().
     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.
     virtual void bell() = 0;
 
diff --git a/common/rfb/VNCServerST.cxx b/common/rfb/VNCServerST.cxx
index 656441a..7807feb 100644
--- a/common/rfb/VNCServerST.cxx
+++ b/common/rfb/VNCServerST.cxx
@@ -518,14 +518,6 @@ void VNCServerST::setScreenLayout(const ScreenSet& layout)
   }
 }
 
-void VNCServerST::requestClipboard()
-{
-  if (clipboardClient == NULL)
-    return;
-
-  clipboardClient->requestClipboard();
-}
-
 void VNCServerST::announceClipboard(bool available)
 {
   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,
                                           const unsigned len)
 {
@@ -1225,13 +1201,6 @@ bool VNCServerST::getComparerState()
   return false;
 }
 
-void VNCServerST::handleClipboardRequest(VNCSConnectionST* client)
-{
-  clipboardRequestors.push_back(client);
-  if (clipboardRequestors.size() == 1)
-    desktop->handleClipboardRequest();
-}
-
 void VNCServerST::handleClipboardAnnounce(VNCSConnectionST* client,
                                           bool available)
 {
@@ -1252,12 +1221,3 @@ void VNCServerST::handleClipboardAnnounceBinary(VNCSConnectionST* client,
   clipboardClient = client;
   desktop->handleClipboardAnnounceBinary(num, mimes);
 }
-
-void VNCServerST::handleClipboardData(VNCSConnectionST* client,
-                                      const char* data, int len)
-{
-  if (client != clipboardClient)
-    return;
-  desktop->handleClipboardData(data, len);
-}
-
diff --git a/common/rfb/VNCServerST.h b/common/rfb/VNCServerST.h
index 0fe3a08..0eff2d1 100644
--- a/common/rfb/VNCServerST.h
+++ b/common/rfb/VNCServerST.h
@@ -96,9 +96,7 @@ namespace rfb {
     virtual void setPixelBuffer(PixelBuffer* pb);
     virtual void setScreenLayout(const ScreenSet& layout);
     virtual PixelBuffer* getPixelBuffer() const { if (DLPRegion.enabled && blackedpb) return blackedpb; else return pb; }
-    virtual void requestClipboard();
     virtual void announceClipboard(bool available);
-    virtual void sendClipboardData(const char* data);
     virtual void clearBinaryClipboardData();
     virtual void sendBinaryClipboardData(const char* mime, const unsigned char *data,
                                          const unsigned len);
@@ -196,11 +194,9 @@ namespace rfb {
 
     void setAPIMessager(network::GetAPIMessager *msgr) { apimessager = msgr; }
 
-    void handleClipboardRequest(VNCSConnectionST* client);
     void handleClipboardAnnounce(VNCSConnectionST* client, bool available);
     void handleClipboardAnnounceBinary(VNCSConnectionST* client, const unsigned num,
                                        const char mimes[][32]);
-    void handleClipboardData(VNCSConnectionST* client, const char* data, int len);
 
   protected:
 
diff --git a/unix/xserver/hw/vnc/XserverDesktop.cc b/unix/xserver/hw/vnc/XserverDesktop.cc
index 5f7b20c..60ea4d3 100644
--- a/unix/xserver/hw/vnc/XserverDesktop.cc
+++ b/unix/xserver/hw/vnc/XserverDesktop.cc
@@ -176,15 +176,6 @@ XserverDesktop::queryConnection(network::Socket* sock,
   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)
 {
   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()
 {
   try {
@@ -500,11 +482,6 @@ unsigned int XserverDesktop::setScreenLayout(int fb_width, int fb_height,
   return ret;
 }
 
-void XserverDesktop::handleClipboardRequest()
-{
-  vncHandleClipboardRequest();
-}
-
 void XserverDesktop::handleClipboardAnnounce(bool available)
 {
   vncHandleClipboardAnnounce(available);
@@ -515,11 +492,6 @@ void XserverDesktop::handleClipboardAnnounceBinary(const unsigned num, const cha
   vncHandleClipboardAnnounceBinary(num, mimes);
 }
 
-void XserverDesktop::handleClipboardData(const char* data_, int len)
-{
-  vncHandleClipboardData(data_, len);
-}
-
 void XserverDesktop::grabRegion(const rfb::Region& region)
 {
   if (directFbptr)
diff --git a/unix/xserver/hw/vnc/XserverDesktop.h b/unix/xserver/hw/vnc/XserverDesktop.h
index 0bcdb4b..c8fc19a 100644
--- a/unix/xserver/hw/vnc/XserverDesktop.h
+++ b/unix/xserver/hw/vnc/XserverDesktop.h
@@ -62,7 +62,6 @@ public:
   void refreshScreenLayout();
   void requestClipboard();
   void announceClipboard(bool available);
-  void sendClipboardData(const char* data);
   void clearBinaryClipboardData();
   void sendBinaryClipboardData(const char* mime, const unsigned char *data,
                                const unsigned len);
@@ -99,10 +98,8 @@ public:
   virtual void keyEvent(rdr::U32 keysym, rdr::U32 keycode, bool down);
   virtual unsigned int setScreenLayout(int fb_width, int fb_height,
                                        const rfb::ScreenSet& layout);
-  virtual void handleClipboardRequest();
   virtual void handleClipboardAnnounce(bool available);
   virtual void handleClipboardAnnounceBinary(const unsigned num, const char mimes[][32]);
-  virtual void handleClipboardData(const char* data, int len);
 
   // rfb::PixelBuffer callbacks
   virtual void grabRegion(const rfb::Region& r);
diff --git a/unix/xserver/hw/vnc/vncExtInit.cc b/unix/xserver/hw/vnc/vncExtInit.cc
index 943b15c..605823c 100644
--- a/unix/xserver/hw/vnc/vncExtInit.cc
+++ b/unix/xserver/hw/vnc/vncExtInit.cc
@@ -352,24 +352,12 @@ void vncUpdateDesktopName(void)
     desktop[scr]->setDesktopName(desktopName);
 }
 
-void vncRequestClipboard(void)
-{
-  for (int scr = 0; scr < vncGetScreenCount(); scr++)
-    desktop[scr]->requestClipboard();
-}
-
 void vncAnnounceClipboard(int available)
 {
   for (int scr = 0; scr < vncGetScreenCount(); scr++)
     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,
                                 const unsigned len)
 {
diff --git a/unix/xserver/hw/vnc/vncExtInit.h b/unix/xserver/hw/vnc/vncExtInit.h
index fd01ab4..0b4abfd 100644
--- a/unix/xserver/hw/vnc/vncExtInit.h
+++ b/unix/xserver/hw/vnc/vncExtInit.h
@@ -67,9 +67,7 @@ int vncGetSendPrimary(void);
 
 void vncUpdateDesktopName(void);
 
-void vncRequestClipboard(void);
 void vncAnnounceClipboard(int available);
-void vncSendClipboardData(const char* data);
 void vncClearBinaryClipboardData();
 void vncSendBinaryClipboardData(const char* mime, const unsigned char *data,
                                 const unsigned len);
diff --git a/unix/xserver/hw/vnc/vncSelection.c b/unix/xserver/hw/vnc/vncSelection.c
index 4d708b1..96c1ade 100644
--- a/unix/xserver/hw/vnc/vncSelection.c
+++ b/unix/xserver/hw/vnc/vncSelection.c
@@ -477,7 +477,7 @@ static int vncConvertSelection(ClientPtr client, Atom selection,
 
       LOG_DEBUG("Requesting clipboard data from client");
 
-      vncRequestClipboard();
+      //vncRequestClipboard();
 
       return Success;
     } else {
@@ -700,7 +700,7 @@ static void vncHandleSelection(Atom selection, Atom target,
     LOG_DEBUG("Sending clipboard to clients (%d bytes)",
               (int)strlen(utf8));
 
-    vncSendClipboardData(utf8);
+    //vncSendClipboardData(utf8);
 
     vncStrFree(utf8);
   } else if (target == xaUTF8_STRING) {
@@ -718,7 +718,7 @@ static void vncHandleSelection(Atom selection, Atom target,
     LOG_DEBUG("Sending clipboard to clients (%d bytes)",
               (int)strlen(filtered));
 
-    vncSendClipboardData(filtered);
+    //vncSendClipboardData(filtered);
 
     vncStrFree(filtered);
   } else {
diff --git a/unix/xserver/hw/vnc/vncSelection.h b/unix/xserver/hw/vnc/vncSelection.h
index 39cb5a9..68266bf 100644
--- a/unix/xserver/hw/vnc/vncSelection.h
+++ b/unix/xserver/hw/vnc/vncSelection.h
@@ -24,10 +24,8 @@ extern "C" {
 
 void vncSelectionInit(void);
 
-void vncHandleClipboardRequest(void);
 void vncHandleClipboardAnnounce(int available);
 void vncHandleClipboardAnnounceBinary(const unsigned num, const char mimes[][32]);
-void vncHandleClipboardData(const char* data, int len);
 
 #ifdef __cplusplus
 }