Clean up internal clipboard handling

We now filter incoming data, which means we can start assuming the
clipboard data is always null terminated. This allows us to clean
up a lot of the internal handling.

common/rfb/CMsgHandler.h

     virtual void setColourMapEntries(int firstColour, int nColours,
 				     rdr::U16* rgbs) = 0;
     virtual void bell() = 0;
-    virtual void serverCutText(const char* str, rdr::U32 len) = 0;
+    virtual void serverCutText(const char* str) = 0;
 
     virtual void setLEDState(unsigned int state);
 

common/rfb/CMsgReader.cxx

   CharArray ca(len);
   is->readBytes(ca.buf, len);
   CharArray filtered(convertLF(ca.buf, len));
-  handler->serverCutText(filtered.buf, strlen(filtered.buf));
+  handler->serverCutText(filtered.buf);
 }
 
 void CMsgReader::readFence()

common/rfb/CMsgWriter.cxx

 }
 
 
-void CMsgWriter::writeClientCutText(const char* str, rdr::U32 len)
+void CMsgWriter::writeClientCutText(const char* str)
 {
-  if (memchr(str, '\r', len) != NULL)
+  size_t len;
+
+  if (strchr(str, '\r') != NULL)
     throw Exception("Invalid carriage return in clipboard data");
 
+  len = strlen(str);
   startMsg(msgTypeClientCutText);
   os->pad(3);
   os->writeU32(len);

common/rfb/CMsgWriter.h

 
     void writeKeyEvent(rdr::U32 keysym, rdr::U32 keycode, bool down);
     void writePointerEvent(const Point& pos, int buttonMask);
-    void writeClientCutText(const char* str, rdr::U32 len);
+    void writeClientCutText(const char* str);
 
   protected:
     void startMsg(int type);

common/rfb/InputHandler.h

                           bool __unused_attr down) { }
     virtual void pointerEvent(const Point& __unused_attr pos,
                               int __unused_attr buttonMask) { }
-    virtual void clientCutText(const char* __unused_attr str,
-                               int __unused_attr len) { }
+    virtual void clientCutText(const char* __unused_attr str) { }
   };
 
 }

common/rfb/SMsgReader.cxx

   CharArray ca(len);
   is->readBytes(ca.buf, len);
   CharArray filtered(convertLF(ca.buf, len));
-  handler->clientCutText(filtered.buf, strlen(filtered.buf));
+  handler->clientCutText(filtered.buf);
 }
 
 void SMsgReader::readQEMUMessage()

common/rfb/SMsgWriter.cxx

   endMsg();
 }
 
-void SMsgWriter::writeServerCutText(const char* str, int len)
+void SMsgWriter::writeServerCutText(const char* str)
 {
-  if (memchr(str, '\r', len) != NULL)
+  size_t len;
+
+  if (strchr(str, '\r') != NULL)
     throw Exception("Invalid carriage return in clipboard data");
 
+  len = strlen(str);
   startMsg(msgTypeServerCutText);
   os->pad(3);
   os->writeU32(len);

common/rfb/SMsgWriter.h

 
     // writeBell() and writeServerCutText() do the obvious thing.
     void writeBell();
-    void writeServerCutText(const char* str, int len);
+    void writeServerCutText(const char* str);
 
     // writeFence() sends a new fence request or response to the client.
     void writeFence(rdr::U32 flags, unsigned len, const char data[]);

common/rfb/VNCSConnectionST.cxx

   }
 }
 
-void VNCSConnectionST::serverCutTextOrClose(const char *str, int len)
+void VNCSConnectionST::serverCutTextOrClose(const char *str)
 {
   try {
     if (!accessCheck(AccessCutText)) return;
     if (!rfb::Server::sendCutText) return;
     if (state() == RFBSTATE_NORMAL)
-      writer()->writeServerCutText(str, len);
+      writer()->writeServerCutText(str);
   } catch(rdr::Exception& e) {
     close(e.str());
   }
   server->keyEvent(keysym, keycode, down);
 }
 
-void VNCSConnectionST::clientCutText(const char* str, int len)
+void VNCSConnectionST::clientCutText(const char* str)
 {
   if (!accessCheck(AccessCutText)) return;
   if (!rfb::Server::acceptCutText) return;
-  server->clientCutText(str, len);
+  server->clientCutText(str);
 }
 
 void VNCSConnectionST::framebufferUpdateRequest(const Rect& r,bool incremental)

common/rfb/VNCSConnectionST.h

     void screenLayoutChangeOrClose(rdr::U16 reason);
     void setCursorOrClose();
     void bellOrClose();
-    void serverCutTextOrClose(const char *str, int len);
+    void serverCutTextOrClose(const char *str);
     void setDesktopNameOrClose(const char *name);
     void setLEDStateOrClose(unsigned int state);
     void approveConnectionOrClose(bool accept, const char* reason);
     virtual void setPixelFormat(const PixelFormat& pf);
     virtual void pointerEvent(const Point& pos, int buttonMask);
     virtual void keyEvent(rdr::U32 keysym, rdr::U32 keycode, bool down);
-    virtual void clientCutText(const char* str, int len);
+    virtual void clientCutText(const char* str);
     virtual void framebufferUpdateRequest(const Rect& r, bool incremental);
     virtual void setDesktopSize(int fb_width, int fb_height,
                                 const ScreenSet& layout);

common/rfb/VNCServer.h

 
     // serverCutText() tells the server that the cut text has changed.  This
     // will normally be sent to all clients.
-    virtual void serverCutText(const char* str, int len) = 0;
+    virtual void serverCutText(const char* str) = 0;
 
     // bell() tells the server that it should make all clients make a bell sound.
     virtual void bell() = 0;

common/rfb/VNCServerST.cxx

   }
 }
 
-void VNCServerST::serverCutText(const char* str, int len)
+void VNCServerST::serverCutText(const char* str)
 {
-  if (memchr(str, '\r', len) != NULL)
+  if (strchr(str, '\r') != NULL)
     throw Exception("Invalid carriage return in clipboard data");
   std::list<VNCSConnectionST*>::iterator ci, ci_next;
   for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
     ci_next = ci; ci_next++;
-    (*ci)->serverCutTextOrClose(str, len);
+    (*ci)->serverCutTextOrClose(str);
   }
 }
 
   desktop->pointerEvent(pos, buttonMask);
 }
 
-void VNCServerST::clientCutText(const char* str, int len)
+void VNCServerST::clientCutText(const char* str)
 {
-  desktop->clientCutText(str, len);
+  desktop->clientCutText(str);
 }
 
 unsigned int VNCServerST::setDesktopSize(VNCSConnectionST* requester,

common/rfb/VNCServerST.h

     virtual void setPixelBuffer(PixelBuffer* pb);
     virtual void setScreenLayout(const ScreenSet& layout);
     virtual const PixelBuffer* getPixelBuffer() const { return pb; }
-    virtual void serverCutText(const char* str, int len);
+    virtual void serverCutText(const char* str);
 
     virtual void approveConnection(network::Socket* sock, bool accept,
                                    const char* reason);
     // Event handlers
     void keyEvent(rdr::U32 keysym, rdr::U32 keycode, bool down);
     void pointerEvent(VNCSConnectionST* client, const Point& pos, int buttonMask);
-    void clientCutText(const char* str, int len);
+    void clientCutText(const char* str);
 
     unsigned int setDesktopSize(VNCSConnectionST* requester,
                                 int fb_width, int fb_height,

tests/decperf.cxx

   virtual void framebufferUpdateEnd();
   virtual void setColourMapEntries(int, int, rdr::U16*);
   virtual void bell();
-  virtual void serverCutText(const char*, rdr::U32);
+  virtual void serverCutText(const char*);
 
 public:
   double cpuTime;
 {
 }
 
-void CConn::serverCutText(const char*, rdr::U32)
+void CConn::serverCutText(const char*)
 {
 }
 

tests/encperf.cxx

   virtual void dataRect(const rfb::Rect&, int);
   virtual void setColourMapEntries(int, int, rdr::U16*);
   virtual void bell();
-  virtual void serverCutText(const char*, rdr::U32);
+  virtual void serverCutText(const char*);
 
 public:
   double decodeTime;
 {
 }
 
-void CConn::serverCutText(const char*, rdr::U32)
+void CConn::serverCutText(const char*)
 {
 }
 

unix/x0vncserver/XDesktop.cxx

 #endif
 }
 
-void XDesktop::clientCutText(const char* str, int len) {
+void XDesktop::clientCutText(const char* str) {
 }
 
 ScreenSet XDesktop::computeScreenLayout()

unix/x0vncserver/XDesktop.h

   virtual void pointerEvent(const rfb::Point& pos, int buttonMask);
   KeyCode XkbKeysymToKeycode(Display* dpy, KeySym keysym);
   virtual void keyEvent(rdr::U32 keysym, rdr::U32 xtcode, bool down);
-  virtual void clientCutText(const char* str, int len);
+  virtual void clientCutText(const char* str);
   virtual unsigned int setScreenLayout(int fb_width, int fb_height,
                                        const rfb::ScreenSet& layout);
 

unix/xserver/hw/vnc/XserverDesktop.cc

   server->setLEDState(state);
 }
 
-void XserverDesktop::serverCutText(const char* str, int len)
+void XserverDesktop::serverCutText(const char* str)
 {
   try {
-    server->serverCutText(str, len);
+    server->serverCutText(str);
   } catch (rdr::Exception& e) {
     vlog.error("XserverDesktop::serverCutText: %s",e.str());
   }
   vncPointerButtonAction(buttonMask);
 }
 
-void XserverDesktop::clientCutText(const char* str, int len)
+void XserverDesktop::clientCutText(const char* str)
 {
-  vncClientCutText(str, len);
+  vncClientCutText(str);
 }
 
 unsigned int XserverDesktop::setScreenLayout(int fb_width, int fb_height,

unix/xserver/hw/vnc/XserverDesktop.h

   void refreshScreenLayout();
   void bell();
   void setLEDState(unsigned int state);
-  void serverCutText(const char* str, int len);
+  void serverCutText(const char* str);
   void setDesktopName(const char* name);
   void setCursor(int width, int height, int hotX, int hotY,
                  const unsigned char *rgbaData);
                                const char* userName);
   virtual void pointerEvent(const rfb::Point& pos, int buttonMask);
   virtual void keyEvent(rdr::U32 keysym, rdr::U32 keycode, bool down);
-  virtual void clientCutText(const char* str, int len);
+  virtual void clientCutText(const char* str);
   virtual unsigned int setScreenLayout(int fb_width, int fb_height,
                                        const rfb::ScreenSet& layout);
 

unix/xserver/hw/vnc/vncExtInit.cc

     desktop[scr]->setDesktopName(desktopName);
 }
 
-void vncServerCutText(const char *text, size_t len)
+void vncServerCutText(const char *text)
 {
   for (int scr = 0; scr < vncGetScreenCount(); scr++)
-    desktop[scr]->serverCutText(text, len);
+    desktop[scr]->serverCutText(text);
 }
 
 int vncConnectClient(const char *addr)

unix/xserver/hw/vnc/vncExtInit.h

 
 void vncUpdateDesktopName(void);
 
-void vncServerCutText(const char *text, size_t len);
+void vncServerCutText(const char *text);
 
 int vncConnectClient(const char *addr);
 

unix/xserver/hw/vnc/vncSelection.c

 static Window wid;
 
 static char* clientCutText;
-static int clientCutTextLen;
 
 static int vncCreateSelectionWindow(void);
 static int vncOwnSelection(Atom selection);
     FatalError("Add VNC SelectionCallback failed\n");
 }
 
-void vncClientCutText(const char* str, int len)
+void vncClientCutText(const char* str)
 {
   int rc;
 
   if (clientCutText != NULL)
     free(clientCutText);
 
-  clientCutText = malloc(len);
+  clientCutText = strdup(str);
   if (clientCutText == NULL) {
     LOG_ERROR("Could not allocate clipboard buffer");
     DeleteWindowFromAnySelections(pWindow);
     return;
   }
 
-  memcpy(clientCutText, str, len);
-  clientCutTextLen = len;
-
   if (vncGetSetPrimary()) {
     rc = vncOwnSelection(xaPRIMARY);
     if (rc != Success)
   } else if ((target == xaSTRING) || (target == xaTEXT)) {
     rc = dixChangeWindowProperty(serverClient, pWin, realProperty,
                                  XA_STRING, 8, PropModeReplace,
-                                 clientCutTextLen, clientCutText,
+                                 strlen(clientCutText), clientCutText,
                                  TRUE);
     if (rc != Success)
       return rc;
     const unsigned char* in;
     size_t in_len;
 
-    buffer = malloc(clientCutTextLen*2);
+    buffer = malloc(strlen(clientCutText)*2);
     if (buffer == NULL)
       return BadAlloc;
 
     out = buffer;
     len = 0;
     in = clientCutText;
-    in_len = clientCutTextLen;
-    while (in_len > 0) {
+    while (*in != '\0') {
       if (*in & 0x80) {
         *out++ = 0xc0 | (*in >> 6);
         *out++ = 0x80 | (*in & 0x3f);
         len += 2;
         in++;
-        in_len--;
       } else {
         *out++ = *in++;
         len++;
-        in_len--;
       }
     }
 
     if (filtered == NULL)
       return;
 
-    vncServerCutText(filtered, strlen(filtered));
+    vncServerCutText(filtered);
 
     vncStrFree(filtered);
   } else if (target == xaUTF8_STRING) {
     if (filtered == NULL)
       return;
 
-    vncServerCutText(filtered, strlen(filtered));
+    vncServerCutText(filtered);
 
     vncStrFree(filtered);
   }

unix/xserver/hw/vnc/vncSelection.h

-/* Copyright 2016 Pierre Ossman for Cendio AB
+/* Copyright 2016-2019 Pierre Ossman for Cendio AB
  * 
  * This is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
 
 void vncSelectionInit(void);
 
-void vncClientCutText(const char* str, int len);
+void vncClientCutText(const char* str);
 
 #ifdef __cplusplus
 }

vncviewer/CConn.cxx

   fl_beep();
 }
 
-void CConn::serverCutText(const char* str, rdr::U32 len)
+void CConn::serverCutText(const char* str)
 {
-  desktop->serverCutText(str, len);
+  desktop->serverCutText(str);
 }
 
 void CConn::dataRect(const Rect& r, int encoding)

vncviewer/CConn.h

 
   void bell();
 
-  void serverCutText(const char* str, rdr::U32 len);
+  void serverCutText(const char* str);
 
   void framebufferUpdateStart();
   void framebufferUpdateEnd();

vncviewer/DesktopWindow.cxx

 }
 
 
-void DesktopWindow::serverCutText(const char* str, rdr::U32 len)
+void DesktopWindow::serverCutText(const char* str)
 {
-  viewport->serverCutText(str, len);
+  viewport->serverCutText(str);
 }
 
 

vncviewer/DesktopWindow.h

   void resizeFramebuffer(int new_w, int new_h);
 
   // Incoming clipboard from server
-  void serverCutText(const char* str, rdr::U32 len);
+  void serverCutText(const char* str);
 
   // New image for the locally rendered cursor
   void setCursor(int width, int height, const rfb::Point& hotspot,

vncviewer/Viewport.cxx

   damage(FL_DAMAGE_USER1, r.tl.x + x(), r.tl.y + y(), r.width(), r.height());
 }
 
-void Viewport::serverCutText(const char* str, rdr::U32 len)
+void Viewport::serverCutText(const char* str)
 {
   char *buffer;
   int size, ret;
   if (!acceptClipboard)
     return;
 
-  size = fl_utf8froma(NULL, 0, str, len);
+  size = fl_utf8froma(NULL, 0, str, strlen(str));
   if (size <= 0)
     return;
 
 
   buffer = new char[size];
 
-  ret = fl_utf8froma(buffer, size, str, len);
+  ret = fl_utf8froma(buffer, size, str, strlen(str));
   assert(ret < size);
 
   vlog.debug("Got clipboard data (%d bytes)", (int)strlen(buffer));
     vlog.debug("Sending clipboard data (%d bytes)", (int)strlen(filtered));
 
     try {
-      cc->writer()->writeClientCutText(filtered, strlen(filtered));
+      cc->writer()->writeClientCutText(filtered);
     } catch (rdr::Exception& e) {
       vlog.error("%s", e.str());
       exit_vncviewer(e.str());
     size_t len = strlen(pendingClientCutText);
     vlog.debug("Sending pending clipboard data (%d bytes)", (int)len);
     try {
-      cc->writer()->writeClientCutText(pendingClientCutText, len);
+      cc->writer()->writeClientCutText(pendingClientCutText);
     } catch (rdr::Exception& e) {
       vlog.error("%s", e.str());
       exit_vncviewer(e.str());

vncviewer/Viewport.h

 /* Copyright (C) 2002-2005 RealVNC Ltd.  All Rights Reserved.
- * Copyright 2011 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright 2011-2019 Pierre Ossman <ossman@cendio.se> for Cendio AB
  * 
  * This is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
   void updateWindow();
 
   // Incoming clipboard from server
-  void serverCutText(const char* str, rdr::U32 len);
+  void serverCutText(const char* str);
 
   // New image for the locally rendered cursor
   void setCursor(int width, int height, const rfb::Point& hotspot,

win/rfb_win32/Clipboard.cxx

             // Notify clients
             if (notifier) {
               if (!clipdata) {
-                notifier->notifyClipboardChanged(0, 0);
+                notifier->notifyClipboardChanged(0);
               } else {
                 CharArray unix_text(convertLF(clipdata, strlen(clipdata)));
                 removeNonISOLatin1Chars(unix_text.buf);
-                notifier->notifyClipboardChanged(unix_text.buf, strlen(unix_text.buf));
+                notifier->notifyClipboardChanged(unix_text.buf);
               }
             } else {
               vlog.debug("no clipboard notifier registered");

win/rfb_win32/Clipboard.h

 /* Copyright (C) 2002-2005 RealVNC Ltd.  All Rights Reserved.
+ * Copyright 2016-2019 Pierre Ossman for Cendio AB
  * 
  * This is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
       // -=- Abstract base class for callback recipients
       class Notifier {
       public:
-        virtual void notifyClipboardChanged(const char* text, int len) = 0;
+        virtual void notifyClipboardChanged(const char* text) = 0;
         virtual ~Notifier() {};
       };
 

win/rfb_win32/SDisplay.cxx

 /* Copyright (C) 2002-2005 RealVNC Ltd.  All Rights Reserved.
+ * Copyright 2011-2019 Pierre Ossman for Cendio AB
  * 
  * This is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
   return false;
 }
 
-void SDisplay::clientCutText(const char* text, int len) {
-  CharArray clip_sz(len+1);
-  memcpy(clip_sz.buf, text, len);
-  clip_sz.buf[len] = 0;
-  clipboard->setClipText(clip_sz.buf);
+void SDisplay::clientCutText(const char* text) {
+  clipboard->setClipText(text);
 }
 
 
 void
-SDisplay::notifyClipboardChanged(const char* text, int len) {
+SDisplay::notifyClipboardChanged(const char* text) {
   vlog.debug("clipboard text changed");
   if (server)
-    server->serverCutText(text, len);
+    server->serverCutText(text);
 }
 
 

win/rfb_win32/SDisplay.h

 /* Copyright (C) 2002-2005 RealVNC Ltd.  All Rights Reserved.
+ * Copyright 2011-2019 Pierre Ossman for Cendio AB
  * 
  * This is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
                                    const char* userName);
       virtual void pointerEvent(const Point& pos, int buttonmask);
       virtual void keyEvent(rdr::U32 keysym, rdr::U32 keycode, bool down);
-      virtual void clientCutText(const char* str, int len);
+      virtual void clientCutText(const char* str);
 
       // -=- Clipboard
       
-      virtual void notifyClipboardChanged(const char* text, int len);
+      virtual void notifyClipboardChanged(const char* text);
 
       // -=- Display events