Return std::string instead of dynamic allocations

We mostly use classical C strings, but the memory management around them
can get confusing and error prone. Let's use std::string for the cases
where we need to return a newly allocated string.

common/network/TcpSocket.cxx

   return new TcpSocket(fd);
 }
 
-void TcpListener::getMyAddresses(std::list<char*>* result) {
+std::list<std::string> TcpListener::getMyAddresses() {
   struct addrinfo *ai, *current, hints;
+  std::list<std::string> result;
 
   initSockets();
 
 
   // Windows doesn't like NULL for service, so specify something
   if ((getaddrinfo(NULL, "1", &hints, &ai)) != 0)
-    return;
+    return result;
 
   for (current= ai; current != NULL; current = current->ai_next) {
+    char addr[INET6_ADDRSTRLEN];
+
     switch (current->ai_family) {
     case AF_INET:
       if (!UseIPv4)
       continue;
     }
 
-    char *addr = new char[INET6_ADDRSTRLEN];
-
     getnameinfo(current->ai_addr, current->ai_addrlen, addr, INET6_ADDRSTRLEN,
                 NULL, 0, NI_NUMERICHOST);
 
-    result->push_back(addr);
+    result.push_back(addr);
   }
 
   freeaddrinfo(ai);
+
+  return result;
 }
 
 int TcpListener::getMyPort() {
   return pattern;
 }
 
-char* TcpFilter::patternToStr(const TcpFilter::Pattern& p) {
+std::string TcpFilter::patternToStr(const TcpFilter::Pattern& p) {
   char addr[INET6_ADDRSTRLEN + 2];
 
   if (p.address.u.sa.sa_family == AF_INET) {
   else
     snprintf(result, resultlen, "%c%s/%u", action, addr, p.prefixlen);
 
-  return result;
+  std::string out = result;
+
+  delete [] result;
+
+  return out;
 }

common/network/TcpSocket.h

 #endif
 
 #include <list>
+#include <string>
 
 /* Tunnelling support. */
 #define TUNNEL_PORT_OFFSET 5500
 
     virtual int getMyPort();
 
-    static void getMyAddresses(std::list<char*>* result);
+    static std::list<std::string> getMyAddresses();
 
   protected:
     virtual Socket* createSocket(int fd);
       vnc_sockaddr_t mask; // computed from address and prefix
     };
     static Pattern parsePattern(const char* s);
-    static char* patternToStr(const Pattern& p);
+    static std::string patternToStr(const Pattern& p);
   protected:
     std::list<Pattern> filter;
   };

common/rfb/CConnection.cxx

   strFree(serverClipboard);
   serverClipboard = NULL;
 
-  serverClipboard = latin1ToUTF8(str);
+  serverClipboard = strDup(latin1ToUTF8(str).c_str());
 
   handleClipboardAnnounce(true);
 }
   strFree(serverClipboard);
   serverClipboard = NULL;
 
-  serverClipboard = convertLF((const char*)data[0], lengths[0]);
+  std::string filtered(convertLF((const char*)data[0], lengths[0]));
+  serverClipboard = strDup(filtered.c_str());
 
   // FIXME: Should probably verify that this data was actually requested
   handleClipboardData(serverClipboard);
 void CConnection::sendClipboardData(const char* data)
 {
   if (server.clipboardFlags() & rfb::clipboardProvide) {
-    CharArray filtered(convertCRLF(data));
-    size_t sizes[1] = { strlen(filtered.buf) + 1 };
-    const uint8_t* data[1] = { (const uint8_t*)filtered.buf };
+    std::string filtered(convertCRLF(data));
+    size_t sizes[1] = { filtered.size() + 1 };
+    const uint8_t* data[1] = { (const uint8_t*)filtered.c_str() };
 
     if (unsolicitedClipboardAttempt) {
       unsolicitedClipboardAttempt = false;
 
     writer()->writeClipboardProvide(rfb::clipboardUTF8, sizes, data);
   } else {
-    CharArray latin1(utf8ToLatin1(data));
+    std::string latin1(utf8ToLatin1(data));
 
-    writer()->writeClientCutText(latin1.buf);
+    writer()->writeClientCutText(latin1.c_str());
   }
 }
 

common/rfb/CMsgHandler.cxx

       if (lengths[i] == 0)
         vlog.debug("    %s (only notify)", type);
       else {
-        char bytes[1024];
-
-        iecPrefix(lengths[i], "B", bytes, sizeof(bytes));
         vlog.debug("    %s (automatically send up to %s)",
-                   type, bytes);
+                   type, iecPrefix(lengths[i], "B").c_str());
       }
     }
   }

common/rfb/CMsgReader.cxx

   }
   CharArray ca(len);
   is->readBytes(ca.buf, len);
-  CharArray filtered(convertLF(ca.buf, len));
-  handler->serverCutText(filtered.buf);
+  std::string filtered(convertLF(ca.buf, len));
+  handler->serverCutText(filtered.c_str());
 
   return true;
 }

common/rfb/CSecurityDH.cxx

 
 void CSecurityDH::writeCredentials()
 {
-  CharArray username;
-  CharArray password;
+  std::string username;
+  std::string password;
   rdr::RandomStream rs;
 
-  (CSecurity::upg)->getUserPasswd(isSecure(), &username.buf, &password.buf);
+  (CSecurity::upg)->getUserPasswd(isSecure(), &username, &password);
+
   std::vector<uint8_t> bBytes(keyLength);
   if (!rs.hasData(keyLength))
     throw ConnFailedException("failed to generate DH private key");
   if (!rs.hasData(128))
     throw ConnFailedException("failed to generate random padding");
   rs.readBytes(buf, 128);
-  size_t len = strlen(username.buf);
-  if (len >= 64)
+  if (username.size() >= 64)
     throw AuthFailureException("username is too long");
-  memcpy(buf, username.buf, len + 1);
-  len = strlen(password.buf);
-  if (len >= 64)
+  memcpy(buf, username.c_str(), username.size() + 1);
+  if (password.size() >= 64)
     throw AuthFailureException("password is too long");
-  memcpy(buf + 64, password.buf, len + 1);
+  memcpy(buf + 64, password.c_str(), password.size() + 1);
   aes128_encrypt(&aesCtx, 128, (uint8_t *)buf, (uint8_t *)buf);
 
   rdr::OutStream* os = cc->getOutStream();

common/rfb/CSecurityMSLogonII.cxx

 
 void CSecurityMSLogonII::writeCredentials()
 {
-  CharArray username;
-  CharArray password;
+  std::string username;
+  std::string password;
   rdr::RandomStream rs;
 
-  (CSecurity::upg)->getUserPasswd(isSecure(), &username.buf, &password.buf);
+  (CSecurity::upg)->getUserPasswd(isSecure(), &username, &password);
+
   std::vector<uint8_t> bBytes(8);
   if (!rs.hasData(8))
     throw ConnFailedException("failed to generate DH private key");
     throw ConnFailedException("failed to generate random padding");
   rs.readBytes(user, 256);
   rs.readBytes(pass, 64);
-  size_t len = strlen(username.buf);
-  if (len >= 256)
+  if (username.size() >= 256)
     throw AuthFailureException("username is too long");
-  memcpy(user, username.buf, len + 1);
-  len = strlen(password.buf);
-  if (len >= 64)
+  memcpy(user, username.c_str(), username.size() + 1);
+  if (password.size() >= 64)
     throw AuthFailureException("password is too long");
-  memcpy(pass, password.buf, len + 1);
+  memcpy(pass, password.c_str(), password.size() + 1);
 
   // DES-CBC with the original key as IV, and the reversed one as the DES key
   struct CBC_CTX(struct des_ctx, DES_BLOCK_SIZE) ctx;

common/rfb/CSecurityPlain.cxx

 #include <rfb/CConnection.h>
 #include <rfb/CSecurityPlain.h>
 #include <rfb/UserPasswdGetter.h>
-#include <rfb/util.h>
 
 #include <rdr/OutStream.h>
 
 {
    rdr::OutStream* os = cc->getOutStream();
 
-  CharArray username;
-  CharArray password;
+  std::string username;
+  std::string password;
 
-  (CSecurity::upg)->getUserPasswd(cc->isSecure(), &username.buf, &password.buf);
+  (CSecurity::upg)->getUserPasswd(cc->isSecure(), &username, &password);
 
   // Return the response to the server
-  os->writeU32(strlen(username.buf));
-  os->writeU32(strlen(password.buf));
-  os->writeBytes(username.buf,strlen(username.buf));
-  os->writeBytes(password.buf,strlen(password.buf));
+  os->writeU32(username.size());
+  os->writeU32(password.size());
+  os->writeBytes(username.data(), username.size());
+  os->writeBytes(password.data(), password.size());
   os->flush();
   return true;
 }

common/rfb/CSecurityRSAAES.cxx

 
 void CSecurityRSAAES::writeCredentials()
 {
-  CharArray username;
-  CharArray password;
+  std::string username;
+  std::string password;
 
-  (CSecurity::upg)->getUserPasswd(
-    isSecure(),
-    subtype == secTypeRA2UserPass ? &username.buf : NULL, &password.buf
-  );
-  size_t len;
-  if (username.buf) {
-    len = strlen(username.buf);
-    if (len > 255)
+  if (subtype == secTypeRA2UserPass)
+    (CSecurity::upg)->getUserPasswd(isSecure(), &username, &password);
+  else
+    (CSecurity::upg)->getUserPasswd(isSecure(), NULL, &password);
+
+  if (subtype == secTypeRA2UserPass) {
+    if (username.size() > 255)
       throw AuthFailureException("username is too long");
-    raos->writeU8(len);
-    if (len)
-      raos->writeBytes(username.buf, len);
+    raos->writeU8(username.size());
+    raos->writeBytes(username.data(), username.size());
   } else {
     raos->writeU8(0);
   }
-  len = strlen(password.buf);
-  if (len > 255)
+
+  if (password.size() > 255)
     throw AuthFailureException("password is too long");
-  raos->writeU8(len);
-  if (len)
-    raos->writeBytes(password.buf, len);
+  raos->writeU8(password.size());
+  raos->writeBytes(password.data(), password.size());
   raos->flush();
 }

common/rfb/CSecurityVncAuth.cxx

 #include <stdio.h>
 
 #include <rfb/CConnection.h>
-#include <rfb/Password.h>
 #include <rfb/CSecurityVncAuth.h>
 #include <rfb/util.h>
 #include <rfb/Security.h>
   // Read the challenge & obtain the user's password
   uint8_t challenge[vncAuthChallengeSize];
   is->readBytes(challenge, vncAuthChallengeSize);
-  PlainPasswd passwd;
-  (CSecurity::upg)->getUserPasswd(cc->isSecure(), 0, &passwd.buf);
+  std::string passwd;
+  (CSecurity::upg)->getUserPasswd(cc->isSecure(), 0, &passwd);
 
   // Calculate the correct response
   uint8_t key[8];
-  int pwdLen = strlen(passwd.buf);
-  for (int i=0; i<8; i++)
-    key[i] = i<pwdLen ? passwd.buf[i] : 0;
+  for (size_t i=0; i<8; i++)
+    key[i] = i<passwd.size() ? passwd[i] : 0;
   deskey(key, EN0);
   for (int j = 0; j < vncAuthChallengeSize; j += 8)
     des(challenge+j, challenge+j);

common/rfb/ComparingUpdateTracker.cxx

 void ComparingUpdateTracker::logStats()
 {
   double ratio;
-  char a[1024], b[1024];
-
-  siPrefix(totalPixels, "pixels", a, sizeof(a));
-  siPrefix(missedPixels, "pixels", b, sizeof(b));
 
   ratio = (double)totalPixels / missedPixels;
 
-  vlog.info("%s in / %s out", a, b);
+  vlog.info("%s in / %s out",
+            siPrefix(totalPixels, "pixels").c_str(),
+            siPrefix(missedPixels, "pixels").c_str());
   vlog.info("(1:%g ratio)", ratio);
 
   totalPixels = missedPixels = 0;

common/rfb/Configuration.cxx

 
   fprintf(stderr, "%s Parameters:\n", name.buf);
   while (current) {
-    char* def_str = current->getDefaultStr();
+    std::string def_str = current->getDefaultStr();
     const char* desc = current->getDescription();
     fprintf(stderr,"  %-*s -", nameWidth, current->getName());
     int column = strlen(current->getName());
       if (!s) break;
     }
 
-    if (def_str) {
-      if (column + (int)strlen(def_str) + 11 > width)
+    if (!def_str.empty()) {
+      if (column + (int)def_str.size() + 11 > width)
         fprintf(stderr,"\n%*s",nameWidth+4,"");
-      fprintf(stderr," (default=%s)\n",def_str);
-      strFree(def_str);
+      fprintf(stderr," (default=%s)\n",def_str.c_str());
     } else {
       fprintf(stderr,"\n");
     }
   return param->setParam();
 }
 
-char*
-AliasParameter::getDefaultStr() const {
-  return 0;
+std::string AliasParameter::getDefaultStr() const {
+  return "";
 }
 
-char* AliasParameter::getValueStr() const {
+std::string AliasParameter::getValueStr() const {
   return param->getValueStr();
 }
 
   vlog.debug("set %s(Bool) to %d", getName(), value);
 }
 
-char*
-BoolParameter::getDefaultStr() const {
-  return strDup(def_value ? "1" : "0");
+std::string BoolParameter::getDefaultStr() const {
+  return def_value ? "1" : "0";
 }
 
-char* BoolParameter::getValueStr() const {
-  return strDup(value ? "1" : "0");
+std::string BoolParameter::getValueStr() const {
+  return value ? "1" : "0";
 }
 
 bool BoolParameter::isBool() const {
   return true;
 }
 
-char*
-IntParameter::getDefaultStr() const {
-  char* result = new char[16];
+std::string IntParameter::getDefaultStr() const {
+  char result[16];
   sprintf(result, "%d", def_value);
   return result;
 }
 
-char* IntParameter::getValueStr() const {
-  char* result = new char[16];
+std::string IntParameter::getValueStr() const {
+  char result[16];
   sprintf(result, "%d", value);
   return result;
 }
   return value != 0;
 }
 
-char* StringParameter::getDefaultStr() const {
-  return strDup(def_value);
+std::string StringParameter::getDefaultStr() const {
+  return def_value;
 }
 
-char* StringParameter::getValueStr() const {
+std::string StringParameter::getValueStr() const {
   LOCK_CONFIG;
-  return strDup(value);
+  return std::string(value);
 }
 
 StringParameter::operator const char *() const {
   }
 }
 
-char* BinaryParameter::getDefaultStr() const {
+std::string BinaryParameter::getDefaultStr() const {
   return binToHex(def_value, def_length);
 }
 
-char* BinaryParameter::getValueStr() const {
+std::string BinaryParameter::getValueStr() const {
   LOCK_CONFIG;
   return binToHex(value, length);
 }

common/rfb/Configuration.h

 
     virtual bool setParam(const char* value)  = 0;
     virtual bool setParam();
-    virtual char* getDefaultStr() const = 0;
-    virtual char* getValueStr() const = 0;
+    virtual std::string getDefaultStr() const = 0;
+    virtual std::string getValueStr() const = 0;
     virtual bool isBool() const;
 
     virtual void setImmutable();
 		   ConfigurationObject co=ConfGlobal);
     virtual bool setParam(const char* value);
     virtual bool setParam();
-    virtual char* getDefaultStr() const;
-    virtual char* getValueStr() const;
+    virtual std::string getDefaultStr() const;
+    virtual std::string getValueStr() const;
     virtual bool isBool() const;
     virtual void setImmutable();
   private:
     virtual bool setParam(const char* value);
     virtual bool setParam();
     virtual void setParam(bool b);
-    virtual char* getDefaultStr() const;
-    virtual char* getValueStr() const;
+    virtual std::string getDefaultStr() const;
+    virtual std::string getValueStr() const;
     virtual bool isBool() const;
     operator bool() const;
   protected:
     using VoidParameter::setParam;
     virtual bool setParam(const char* value);
     virtual bool setParam(int v);
-    virtual char* getDefaultStr() const;
-    virtual char* getValueStr() const;
+    virtual std::string getDefaultStr() const;
+    virtual std::string getValueStr() const;
     operator int() const;
   protected:
     int value;
 		    ConfigurationObject co=ConfGlobal);
     virtual ~StringParameter();
     virtual bool setParam(const char* value);
-    virtual char* getDefaultStr() const;
-    virtual char* getValueStr() const;
+    virtual std::string getDefaultStr() const;
+    virtual std::string getValueStr() const;
     operator const char*() const;
-
-    // getData() returns a copy of the data - it must be delete[]d by the
-    // caller.
-    char* getData() const { return getValueStr(); }
   protected:
     char* value;
     char* def_value;
     virtual ~BinaryParameter();
     virtual bool setParam(const char* value);
     virtual void setParam(const uint8_t* v, size_t l);
-    virtual char* getDefaultStr() const;
-    virtual char* getValueStr() const;
+    virtual std::string getDefaultStr() const;
+    virtual std::string getValueStr() const;
 
     std::vector<uint8_t> getData() const;
 

common/rfb/DecodeManager.cxx

 
   double ratio;
 
-  char a[1024], b[1024];
-
   rects = 0;
   pixels = bytes = equivalent = 0;
 
 
     ratio = (double)stats[i].equivalent / stats[i].bytes;
 
-    siPrefix(stats[i].rects, "rects", a, sizeof(a));
-    siPrefix(stats[i].pixels, "pixels", b, sizeof(b));
-    vlog.info("    %s: %s, %s", encodingName(i), a, b);
-    iecPrefix(stats[i].bytes, "B", a, sizeof(a));
+    vlog.info("    %s: %s, %s", encodingName(i),
+              siPrefix(stats[i].rects, "rects").c_str(),
+              siPrefix(stats[i].pixels, "pixels").c_str());
     vlog.info("    %*s  %s (1:%g ratio)",
               (int)strlen(encodingName(i)), "",
-              a, ratio);
+              iecPrefix(stats[i].bytes, "B").c_str(), ratio);
   }
 
   ratio = (double)equivalent / bytes;
 
-  siPrefix(rects, "rects", a, sizeof(a));
-  siPrefix(pixels, "pixels", b, sizeof(b));
-  vlog.info("  Total: %s, %s", a, b);
-  iecPrefix(bytes, "B", a, sizeof(a));
-  vlog.info("         %s (1:%g ratio)", a, ratio);
+  vlog.info("  Total: %s, %s",
+            siPrefix(rects, "rects").c_str(),
+            siPrefix(pixels, "pixels").c_str());
+  vlog.info("         %s (1:%g ratio)",
+            iecPrefix(bytes, "B").c_str(), ratio);
 }
 
 void DecodeManager::setThreadException(const rdr::Exception& e)

common/rfb/EncodeManager.cxx

 
   double ratio;
 
-  char a[1024], b[1024];
-
   rects = 0;
   pixels = bytes = equivalent = 0;
 
 
     ratio = (double)copyStats.equivalent / copyStats.bytes;
 
-    siPrefix(copyStats.rects, "rects", a, sizeof(a));
-    siPrefix(copyStats.pixels, "pixels", b, sizeof(b));
-    vlog.info("    %s: %s, %s", "Copies", a, b);
-    iecPrefix(copyStats.bytes, "B", a, sizeof(a));
+    vlog.info("    %s: %s, %s", "Copies",
+              siPrefix(copyStats.rects, "rects").c_str(),
+              siPrefix(copyStats.pixels, "pixels").c_str());
     vlog.info("    %*s  %s (1:%g ratio)",
               (int)strlen("Copies"), "",
-              a, ratio);
+              iecPrefix(copyStats.bytes, "B").c_str(), ratio);
   }
 
   for (i = 0;i < stats.size();i++) {
 
       ratio = (double)stats[i][j].equivalent / stats[i][j].bytes;
 
-      siPrefix(stats[i][j].rects, "rects", a, sizeof(a));
-      siPrefix(stats[i][j].pixels, "pixels", b, sizeof(b));
-      vlog.info("    %s: %s, %s", encoderTypeName((EncoderType)j), a, b);
-      iecPrefix(stats[i][j].bytes, "B", a, sizeof(a));
+      vlog.info("    %s: %s, %s", encoderTypeName((EncoderType)j),
+                siPrefix(stats[i][j].rects, "rects").c_str(),
+                siPrefix(stats[i][j].pixels, "pixels").c_str());
       vlog.info("    %*s  %s (1:%g ratio)",
                 (int)strlen(encoderTypeName((EncoderType)j)), "",
-                a, ratio);
+                iecPrefix(stats[i][j].bytes, "B").c_str(), ratio);
     }
   }
 
   ratio = (double)equivalent / bytes;
 
-  siPrefix(rects, "rects", a, sizeof(a));
-  siPrefix(pixels, "pixels", b, sizeof(b));
-  vlog.info("  Total: %s, %s", a, b);
-  iecPrefix(bytes, "B", a, sizeof(a));
-  vlog.info("         %s (1:%g ratio)", a, ratio);
+  vlog.info("  Total: %s, %s",
+            siPrefix(rects, "rects").c_str(),
+            siPrefix(pixels, "pixels").c_str());
+  vlog.info("         %s (1:%g ratio)",
+            iecPrefix(bytes, "B").c_str(), ratio);
 }
 
 bool EncodeManager::supported(int encoding)

common/rfb/Hostname.h

     return true;
   }
 
-  static void getHostAndPort(const char* hi, char** host, int* port, int basePort=5900) {
+  static void getHostAndPort(const char* hi, std::string* host,
+                             int* port, int basePort=5900)
+  {
     const char* hostStart;
     const char* hostEnd;
     const char* portStart;
       hostEnd--;
 
     if (hostStart == hostEnd)
-      *host = strDup("localhost");
-    else {
-      size_t len;
-      len = hostEnd - hostStart + 1;
-      *host = new char[len];
-      strncpy(*host, hostStart, len-1);
-      (*host)[len-1] = '\0';
-    }
+      *host = "localhost";
+    else
+      *host = std::string(hostStart, hostEnd - hostStart);
 
     if (portStart == NULL)
       *port = basePort;

common/rfb/LogWriter.cxx

   LogWriter::setLogParams("*::0");
   StringParameter::setParam(v);
   CharArray logParam;
-  CharArray params(getData());
+  CharArray params(strDup(getValueStr().c_str()));
   while (params.buf) {
     strSplit(params.buf, ',', &logParam.buf, &params.buf);
     if (strlen(logParam.buf) && !LogWriter::setLogParams(logParam.buf))

common/rfb/SConnection.cxx

   strFree(clientClipboard);
   clientClipboard = NULL;
 
-  clientClipboard = latin1ToUTF8(str);
+  clientClipboard = strDup(latin1ToUTF8(str).c_str());
 
   handleClipboardAnnounce(true);
 }
   strFree(clientClipboard);
   clientClipboard = NULL;
 
-  clientClipboard = convertLF((const char*)data[0], lengths[0]);
+  std::string filtered(convertLF((const char*)data[0], lengths[0]));
+  clientClipboard = strDup(filtered.c_str());
 
   // FIXME: Should probably verify that this data was actually requested
   handleClipboardData(clientClipboard);
 {
   if (client.supportsEncoding(pseudoEncodingExtendedClipboard) &&
       (client.clipboardFlags() & rfb::clipboardProvide)) {
-    CharArray filtered(convertCRLF(data));
-    size_t sizes[1] = { strlen(filtered.buf) + 1 };
-    const uint8_t* data[1] = { (const uint8_t*)filtered.buf };
+    std::string filtered(convertCRLF(data));
+    size_t sizes[1] = { filtered.size() + 1 };
+    const uint8_t* data[1] = { (const uint8_t*)filtered.c_str() };
 
     if (unsolicitedClipboardAttempt) {
       unsolicitedClipboardAttempt = false;
 
     writer()->writeClipboardProvide(rfb::clipboardUTF8, sizes, data);
   } else {
-    CharArray latin1(utf8ToLatin1(data));
+    std::string latin1(utf8ToLatin1(data));
 
-    writer()->writeServerCutText(latin1.buf);
+    writer()->writeServerCutText(latin1.c_str());
   }
 }
 

common/rfb/SMsgHandler.cxx

       if (lengths[i] == 0)
         vlog.debug("    %s (only notify)", type);
       else {
-        char bytes[1024];
-
-        iecPrefix(lengths[i], "B", bytes, sizeof(bytes));
         vlog.debug("    %s (automatically send up to %s)",
-                   type, bytes);
+                   type, iecPrefix(lengths[i], "B").c_str());
       }
     }
   }

common/rfb/SMsgReader.cxx

 
   CharArray ca(len);
   is->readBytes(ca.buf, len);
-  CharArray filtered(convertLF(ca.buf, len));
-  handler->clientCutText(filtered.buf);
+  std::string filtered(convertLF(ca.buf, len));
+  handler->clientCutText(filtered.c_str());
 
   return true;
 }

common/rfb/SSecurityPlain.cxx

 
 bool PasswordValidator::validUser(const char* username)
 {
-  CharArray users(plainUsers.getValueStr()), user;
+  CharArray users(strDup(plainUsers.getValueStr().c_str()));
+  CharArray user;
 
   while (users.buf) {
     strSplit(users.buf, ',', &user.buf, &users.buf);

common/rfb/UserPasswdGetter.h

  */
 #ifndef __RFB_USERPASSWDGETTER_H__
 #define __RFB_USERPASSWDGETTER_H__
+
+#include <string>
+
 namespace rfb {
   class UserPasswdGetter {
   public:
     // getUserPasswd gets the username and password.  This might involve a
     // dialog, getpass(), etc.  The user buffer pointer can be null, in which
-    // case no user name will be retrieved.  The caller MUST delete [] the
-    // result(s).
-    virtual void getUserPasswd(bool secure, char** user, char** password)=0;
+    // case no user name will be retrieved.
+    virtual void getUserPasswd(bool secure, std::string* user,
+                               std::string* password)=0;
 
     virtual ~UserPasswdGetter() {}
   };
 }
+
 #endif

common/rfb/util.cxx

     delete [] s;
   }
 
-  void strFree(wchar_t* s) {
-    delete [] s;
-  }
-
 
   bool strSplit(const char* src, const char limiter, char** out1, char** out2, bool fromEnd) {
     CharArray out1old, out2old;
     }
   }
 
-  char* binToHex(const uint8_t* in, size_t inlen) {
-    char* out = new char[inlen*2+1]();
-    binToHex(in, inlen, out, inlen*2);
+  std::string binToHex(const uint8_t* in, size_t inlen) {
+    char* buffer = new char[inlen*2+1]();
+    std::string out;
+    binToHex(in, inlen, buffer, inlen*2);
+    out = buffer;
+    delete [] buffer;
     return out;
   }
 
     return out;
   }
 
-  char* convertLF(const char* src, size_t bytes)
+  std::string convertLF(const char* src, size_t bytes)
   {
-    char* buffer;
     size_t sz;
+    std::string out;
 
-    char* out;
     const char* in;
     size_t in_len;
 
-    // Always include space for a NULL
-    sz = 1;
-
     // Compute output size
+    sz = 0;
     in = src;
     in_len = bytes;
     while ((in_len > 0) && (*in != '\0')) {
       in_len--;
     }
 
-    // Alloc
-    buffer = new char[sz];
-    memset(buffer, 0, sz);
+    // Reserve space
+    out.reserve(sz);
 
     // And convert
-    out = buffer;
     in = src;
     in_len = bytes;
     while ((in_len > 0) && (*in != '\0')) {
       if (*in != '\r') {
-        *out++ = *in++;
+        out += *in++;
         in_len--;
         continue;
       }
 
       if ((in_len < 2) || (*(in+1) != '\n'))
-        *out++ = '\n';
+        out += '\n';
 
       in++;
       in_len--;
     }
 
-    return buffer;
+    return out;
   }
 
-  char* convertCRLF(const char* src, size_t bytes)
+  std::string convertCRLF(const char* src, size_t bytes)
   {
-    char* buffer;
+    std::string out;
     size_t sz;
 
-    char* out;
     const char* in;
     size_t in_len;
 
-    // Always include space for a NULL
-    sz = 1;
-
     // Compute output size
+    sz = 0;
     in = src;
     in_len = bytes;
     while ((in_len > 0) && (*in != '\0')) {
       in_len--;
     }
 
-    // Alloc
-    buffer = new char[sz];
-    memset(buffer, 0, sz);
+    // Reserve space
+    out.reserve(sz);
 
     // And convert
-    out = buffer;
     in = src;
     in_len = bytes;
     while ((in_len > 0) && (*in != '\0')) {
       if (*in == '\n') {
         if ((in == src) || (*(in-1) != '\r'))
-          *out++ = '\r';
+          out += '\r';
       }
 
-      *out = *in;
+      out += *in;
 
       if (*in == '\r') {
-        if ((in_len < 2) || (*(in+1) != '\n')) {
-          out++;
-          *out = '\n';
-        }
+        if ((in_len < 2) || (*(in+1) != '\n'))
+          out += '\n';
       }
 
-      out++;
       in++;
       in_len--;
     }
 
-    return buffer;
+    return out;
   }
 
   size_t ucs4ToUTF8(unsigned src, char dst[5]) {
     return 2;
   }
 
-  char* latin1ToUTF8(const char* src, size_t bytes) {
-    char* buffer;
+  std::string latin1ToUTF8(const char* src, size_t bytes) {
+    std::string out;
     size_t sz;
 
-    char* out;
     const char* in;
     size_t in_len;
 
-    // Always include space for a NULL
-    sz = 1;
-
     // Compute output size
+    sz = 0;
     in = src;
     in_len = bytes;
     while ((in_len > 0) && (*in != '\0')) {
       in_len--;
     }
 
-    // Alloc
-    buffer = new char[sz];
-    memset(buffer, 0, sz);
+    // Reserve space
+    out.reserve(sz);
 
     // And convert
-    out = buffer;
     in = src;
     in_len = bytes;
     while ((in_len > 0) && (*in != '\0')) {
-      out += ucs4ToUTF8(*(const unsigned char*)in, out);
+      char buf[5];
+      ucs4ToUTF8(*(const unsigned char*)in, buf);
+      out += buf;
       in++;
       in_len--;
     }
 
-    return buffer;
+    return out;
   }
 
-  char* utf8ToLatin1(const char* src, size_t bytes) {
-    char* buffer;
+  std::string utf8ToLatin1(const char* src, size_t bytes) {
+    std::string out;
     size_t sz;
 
-    char* out;
     const char* in;
     size_t in_len;
 
-    // Always include space for a NULL
-    sz = 1;
-
     // Compute output size
+    sz = 0;
     in = src;
     in_len = bytes;
     while ((in_len > 0) && (*in != '\0')) {
       sz++;
     }
 
-    // Alloc
-    buffer = new char[sz];
-    memset(buffer, 0, sz);
+    // Reserve space
+    out.reserve(sz);
 
     // And convert
-    out = buffer;
     in = src;
     in_len = bytes;
     while ((in_len > 0) && (*in != '\0')) {
       in_len -= len;
 
       if (ucs > 0xff)
-        *out++ = '?';
+        out += '?';
       else
-        *out++ = (unsigned char)ucs;
+        out += (unsigned char)ucs;
     }
 
-    return buffer;
+    return out;
   }
 
-  char* utf16ToUTF8(const wchar_t* src, size_t units)
+  std::string utf16ToUTF8(const wchar_t* src, size_t units)
   {
-    char* buffer;
+    std::string out;
     size_t sz;
 
-    char* out;
     const wchar_t* in;
     size_t in_len;
 
-    // Always include space for a NULL
-    sz = 1;
-
     // Compute output size
+    sz = 0;
     in = src;
     in_len = units;
     while ((in_len > 0) && (*in != '\0')) {
       sz += ucs4ToUTF8(ucs, buf);
     }
 
-    // Alloc
-    buffer = new char[sz];
-    memset(buffer, 0, sz);
+    // Reserve space
+    out.reserve(sz);
 
     // And convert
-    out = buffer;
     in = src;
     in_len = units;
     while ((in_len > 0) && (*in != '\0')) {
       size_t len;
       unsigned ucs;
+      char buf[5];
 
       len = utf16ToUCS4(in, in_len, &ucs);
       in += len;
       in_len -= len;
 
-      out += ucs4ToUTF8(ucs, out);
+      ucs4ToUTF8(ucs, buf);
+      out += buf;
     }
 
-    return buffer;
+    return out;
   }
 
-  wchar_t* utf8ToUTF16(const char* src, size_t bytes)
+  std::wstring utf8ToUTF16(const char* src, size_t bytes)
   {
-    wchar_t* buffer;
+    std::wstring out;
     size_t sz;
 
-    wchar_t* out;
     const char* in;
     size_t in_len;
 
-    // Always include space for a NULL
-    sz = 1;
-
     // Compute output size
+    sz = 0;
     in = src;
     in_len = bytes;
     while ((in_len > 0) && (*in != '\0')) {
       sz += ucs4ToUTF16(ucs, buf);
     }
 
-    // Alloc
-    buffer = new wchar_t[sz];
-    memset(buffer, 0, sz * sizeof(wchar_t));
+    // Reserve space
+    out.reserve(sz);
 
     // And convert
-    out = buffer;
     in = src;
     in_len = bytes;
     while ((in_len > 0) && (*in != '\0')) {
       size_t len;
       unsigned ucs;
+      wchar_t buf[3];
 
       len = utf8ToUCS4(in, in_len, &ucs);
       in += len;
       in_len -= len;
 
-      out += ucs4ToUTF16(ucs, out);
+      ucs4ToUTF16(ucs, buf);
+      out += buf;
     }
 
-    return buffer;
+    return out;
   }
 
   unsigned msBetween(const struct timeval *first,
     return false;
   }
 
-  static size_t doPrefix(long long value, const char *unit,
-                         char *buffer, size_t maxlen,
-                         unsigned divisor, const char **prefixes,
-                         size_t prefixCount, int precision) {
+  static std::string doPrefix(long long value, const char *unit,
+                              unsigned divisor, const char **prefixes,
+                              size_t prefixCount, int precision) {
+    char buffer[256];
     double newValue;
-    size_t prefix, len;
+    size_t prefix;
 
     newValue = value;
     prefix = 0;
       prefix++;
     }
 
-    len = snprintf(buffer, maxlen, "%.*g %s%s", precision, newValue,
-                   (prefix == 0) ? "" : prefixes[prefix-1], unit);
-    buffer[maxlen-1] = '\0';
+    snprintf(buffer, sizeof(buffer), "%.*g %s%s", precision, newValue,
+             (prefix == 0) ? "" : prefixes[prefix-1], unit);
+    buffer[sizeof(buffer)-1] = '\0';
 
-    return len;
+    return buffer;
   }
 
   static const char *siPrefixes[] =
   static const char *iecPrefixes[] =
     { "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi" };
 
-  size_t siPrefix(long long value, const char *unit,
-                  char *buffer, size_t maxlen, int precision) {
-    return doPrefix(value, unit, buffer, maxlen, 1000, siPrefixes,
+  std::string siPrefix(long long value, const char *unit,
+                       int precision) {
+    return doPrefix(value, unit, 1000, siPrefixes,
                     sizeof(siPrefixes)/sizeof(*siPrefixes),
                     precision);
   }
 
-  size_t iecPrefix(long long value, const char *unit,
-                   char *buffer, size_t maxlen, int precision) {
-    return doPrefix(value, unit, buffer, maxlen, 1024, iecPrefixes,
+  std::string iecPrefix(long long value, const char *unit,
+                        int precision) {
+    return doPrefix(value, unit, 1024, iecPrefixes,
                     sizeof(iecPrefixes)/sizeof(*iecPrefixes),
                     precision);
   }

common/rfb/util.h

 #include <string.h>
 #include <stdint.h>
 
+#include <string>
 #include <vector>
 
 struct timeval;
 
   char* strDup(const char* s);
   void strFree(char* s);
-  void strFree(wchar_t* s);
 
   // Returns true if split successful.  Returns false otherwise.
   // ALWAYS *copies* first part of string to out1 buffer.
   // Conversion to and from a hex string
 
   void binToHex(const uint8_t* in, size_t inlen, char* out, size_t outlen);
-  char* binToHex(const uint8_t* in, size_t inlen);
+  std::string binToHex(const uint8_t* in, size_t inlen);
   bool hexToBin(const char* in, size_t inlen, uint8_t* out, size_t outlen);
   std::vector<uint8_t> hexToBin(const char* in, size_t inlen);
 
   // Makes sure line endings are in a certain format
 
-  char* convertLF(const char* src, size_t bytes = (size_t)-1);
-  char* convertCRLF(const char* src, size_t bytes = (size_t)-1);
+  std::string convertLF(const char* src, size_t bytes = (size_t)-1);
+  std::string convertCRLF(const char* src, size_t bytes = (size_t)-1);
 
-  // Convertions between various Unicode formats. The returned strings are
-  // always null terminated and must be freed using strFree().
+  // Convertions between various Unicode formats
 
   size_t ucs4ToUTF8(unsigned src, char dst[5]);
   size_t utf8ToUCS4(const char* src, size_t max, unsigned* dst);
   size_t ucs4ToUTF16(unsigned src, wchar_t dst[3]);
   size_t utf16ToUCS4(const wchar_t* src, size_t max, unsigned* dst);
 
-  char* latin1ToUTF8(const char* src, size_t bytes = (size_t)-1);
-  char* utf8ToLatin1(const char* src, size_t bytes = (size_t)-1);
+  std::string latin1ToUTF8(const char* src, size_t bytes = (size_t)-1);
+  std::string utf8ToLatin1(const char* src, size_t bytes = (size_t)-1);
 
-  char* utf16ToUTF8(const wchar_t* src, size_t units = (size_t)-1);
-  wchar_t* utf8ToUTF16(const char* src, size_t bytes = (size_t)-1);
+  std::string utf16ToUTF8(const wchar_t* src, size_t units = (size_t)-1);
+  std::wstring utf8ToUTF16(const char* src, size_t bytes = (size_t)-1);
 
   // HELPER functions for timeout handling
 
   bool isBefore(const struct timeval *first,
                 const struct timeval *second);
 
-  size_t siPrefix(long long value, const char *unit,
-                  char *buffer, size_t maxlen, int precision=6);
-  size_t iecPrefix(long long value, const char *unit,
-                   char *buffer, size_t maxlen, int precision=6);
+  std::string siPrefix(long long value, const char *unit,
+                       int precision=6);
+  std::string iecPrefix(long long value, const char *unit,
+                        int precision=6);
 }
 
 // Some platforms (e.g. Windows) include max() and min() macros in their

tests/perf/fbperf.cxx

   double time[3];
 
   double delay, rate;
-  char s[1024];
 
   // Run the test several times at different resolutions...
   dosubtest(win, 800, 600, &pixels[0], &frames[0], &time[0]);
   }
 
   fprintf(stderr, "Rendering delay: %g ms/frame\n", delay * 1000.0);
-  if (rate == 0.0)
-    strcpy(s, "N/A pixels/s");
-  else
-    rfb::siPrefix(1.0 / rate, "pixels/s", s, sizeof(s));
-  fprintf(stderr, "Rendering rate: %s\n", s);
+  fprintf(stderr, "Rendering rate: %s\n",
+          (rate == 0.0) ? "N/A pixels/s" :
+                          rfb::siPrefix(1.0 / rate, "pixels/s").c_str());
   fprintf(stderr, "Maximum FPS: %g fps @ 1920x1080\n",
           1.0 / (delay + rate * 1920 * 1080));
 }

tests/unit/convertlf.cxx

 
 static void testLF(const char* input, const char* expected)
 {
-    char* output;
+    std::string output;
 
     printf("convertLF(\"%s\"): ", escape(input));
 
     output = rfb::convertLF(input);
 
-    if (strcmp(output, expected) != 0)
-        printf("FAILED: got \"%s\"", escape(output));
+    if (output != expected)
+        printf("FAILED: got \"%s\"", escape(output.c_str()));
     else
         printf("OK");
     printf("\n");
     fflush(stdout);
-
-    rfb::strFree(output);
 }
 
 static void testCRLF(const char* input, const char* expected)
 {
-    char* output;
+    std::string output;
 
     printf("convertCRLF(\"%s\"): ", escape(input));
 
     output = rfb::convertCRLF(input);
 
-    if (strcmp(output, expected) != 0)
-        printf("FAILED: got \"%s\"", escape(output));
+    if (output != expected)
+        printf("FAILED: got \"%s\"", escape(output.c_str()));
     else
         printf("OK");
     printf("\n");
     fflush(stdout);
-
-    rfb::strFree(output);
 }
 
 int main(int /*argc*/, char** /*argv*/)

tests/unit/hostport.cxx

 static void doTest(const char* hostAndPort,
                    const char* expectedHost, int expectedPort)
 {
-    char* host;
+    std::string host;
     int port;
 
     printf("\"%s\": ", hostAndPort);
 
     rfb::getHostAndPort(hostAndPort, &host, &port);
 
-    if (strcmp(host, expectedHost) != 0)
-        printf("FAILED (\"%s\" != \"%s\")", host, expectedHost);
+    if (host != expectedHost)
+        printf("FAILED (\"%s\" != \"%s\")", host.c_str(), expectedHost);
     else if (port != expectedPort)
         printf("FAILED (%d != %d)", port, expectedPort);
     else
         printf("OK");
     printf("\n");
     fflush(stdout);
-
-    rfb::strFree(host);
 }
 
 int main(int /*argc*/, char** /*argv*/)

tests/unit/unicode.cxx

     unsigned ucs4;
     char utf8[5];
     wchar_t utf16[3];
-    char *out;
-    wchar_t *wout;
+    std::string out;
+    std::wstring wout;
     size_t len;
 
     failures = 0;
             continue;
 
         out = rfb::latin1ToUTF8(latin1utf8[i].latin1);
-        if (strcmp(out, latin1utf8[i].utf8) != 0) {
+        if (out != latin1utf8[i].utf8) {
             printf("FAILED: latin1ToUTF8() #%d\n", (int)i+1);
             failures++;
         }
-        rfb::strFree(out);
     }
 
     for (i = 0;i < ARRAY_SIZE(latin1utf8);i++) {
         out = rfb::utf8ToLatin1(latin1utf8[i].utf8);
-        if (strcmp(out, latin1utf8[i].latin1) != 0) {
+        if (out != latin1utf8[i].latin1) {
             printf("FAILED: utf8ToLatin1() #%d\n", (int)i+1);
             failures++;
         }
-        rfb::strFree(out);
     }
 
     for (i = 0;i < ARRAY_SIZE(utf8utf16);i++) {
             continue;
 
         out = rfb::utf16ToUTF8(utf8utf16[i].utf16);
-        if (strcmp(out, utf8utf16[i].utf8) != 0) {
+        if (out != utf8utf16[i].utf8) {
             printf("FAILED: utf16ToUTF8() #%d\n", (int)i+1);
             failures++;
         }
-        rfb::strFree(out);
     }
 
     for (i = 0;i < ARRAY_SIZE(utf8utf16);i++) {
             continue;
 
         wout = rfb::utf8ToUTF16(utf8utf16[i].utf8);
-        if (wcscmp(wout, utf8utf16[i].utf16) != 0) {
+        if (wout != utf8utf16[i].utf16) {
             printf("FAILED: utf8ToUTF16() #%d\n", (int)i+1);
             failures++;
         }
-        rfb::strFree(wout);
     }
 
     if (failures == 0) {

unix/xserver/hw/vnc/RFBGlue.cc

 
 char* vncGetParam(const char *name)
 {
-  rfb::VoidParameter *param;
-  char *value;
-  char *ret;
+  VoidParameter *param;
 
   // Hack to avoid exposing password!
   if (strcasecmp(name, "Password") == 0)
   if (param == NULL)
     return NULL;
 
-  value = param->getValueStr();
-  if (value == NULL)
-    return NULL;
-
-  ret = strdup(value);
-
-  delete [] value;
-
-  return ret;
+  return strdup(param->getValueStr().c_str());
 }
 
 const char* vncGetParamDesc(const char *name)
 char* vncConvertLF(const char* src, size_t bytes)
 {
   try {
-    return convertLF(src, bytes);
+    return strDup(convertLF(src, bytes).c_str());
   } catch (...) {
     return NULL;
   }
 char* vncLatin1ToUTF8(const char* src, size_t bytes)
 {
   try {
-    return latin1ToUTF8(src, bytes);
+    return strDup(latin1ToUTF8(src, bytes).c_str());
   } catch (...) {
     return NULL;
   }
 char* vncUTF8ToLatin1(const char* src, size_t bytes)
 {
   try {
-    return utf8ToLatin1(src, bytes);
+    return strDup(utf8ToLatin1(src, bytes).c_str());
   } catch (...) {
     return NULL;
   }

unix/xserver/hw/vnc/vncExtInit.cc

     return 0;
   }
 
-  char *host;
+  std::string host;
   int port;
 
   getHostAndPort(addr, &host, &port, 5500);
 
   try {
-    network::Socket* sock = new network::TcpSocket(host, port);
-    delete [] host;
+    network::Socket* sock = new network::TcpSocket(host.c_str(), port);
     desktop[0]->addClient(sock, true);
   } catch (rdr::Exception& e) {
     vlog.error("Reverse connection: %s",e.str());

vncviewer/CConn.cxx

 static const unsigned bpsEstimateWindow = 1000;
 
 CConn::CConn(const char* vncServerName, network::Socket* socket=NULL)
-  : serverHost(0), serverPort(0), desktop(NULL),
-    updateCount(0), pixelCount(0),
+  : serverPort(0), desktop(NULL), updateCount(0), pixelCount(0),
     lastServerEncoding((unsigned int)-1), bpsEstimate(20000000)
 {
   setShared(::shared);
 #ifndef WIN32
       if (strchr(vncServerName, '/') != NULL) {
         sock = new network::UnixSocket(vncServerName);
-        serverHost = strDup(sock->getPeerAddress());
-        vlog.info(_("Connected to socket %s"), serverHost);
+        serverHost = sock->getPeerAddress();
+        vlog.info(_("Connected to socket %s"), serverHost.c_str());
       } else
 #endif
       {
         getHostAndPort(vncServerName, &serverHost, &serverPort);
 
-        sock = new network::TcpSocket(serverHost, serverPort);
-        vlog.info(_("Connected to host %s port %d"), serverHost, serverPort);
+        sock = new network::TcpSocket(serverHost.c_str(), serverPort);
+        vlog.info(_("Connected to host %s port %d"),
+                  serverHost.c_str(), serverPort);
       }
     } catch (rdr::Exception& e) {
       vlog.error("%s", e.str());
 
   Fl::add_fd(sock->getFd(), FL_READ | FL_EXCEPT, socketEvent, this);
 
-  setServerName(serverHost);
+  setServerName(serverHost.c_str());
   setStreams(&sock->inStream(), &sock->outStream());
 
   initialiseProtocol();
   if (desktop)
     delete desktop;
 
-  delete [] serverHost;
   if (sock)
     Fl::remove_fd(sock->getFd());
   delete sock;
   strcat(infoText, "\n");
 
   snprintf(scratch, sizeof(scratch),
-           _("Host: %.80s port: %d"), serverHost, serverPort);
+           _("Host: %.80s port: %d"), serverHost.c_str(), serverPort);
   strcat(infoText, scratch);
   strcat(infoText, "\n");
 

vncviewer/CConn.h

   static void handleUpdateTimeout(void *data);
 
 private:
-  char* serverHost;
+  std::string serverHost;
   int serverPort;
   network::Socket* sock;
 

vncviewer/DesktopWindow.cxx

   fl_draw(buffer, 5, statsHeight - 5);
 
   fl_color(FL_YELLOW);
-  siPrefix(self->stats[statsCount-1].pps, "pix/s",
-           buffer, sizeof(buffer), 3);
-  fl_draw(buffer, 5 + (statsWidth-10)/3, statsHeight - 5);
+  fl_draw(siPrefix(self->stats[statsCount-1].pps, "pix/s").c_str(),
+          5 + (statsWidth-10)/3, statsHeight - 5);
 
   fl_color(FL_RED);
-  siPrefix(self->stats[statsCount-1].bps * 8, "bps",
-           buffer, sizeof(buffer), 3);
-  fl_draw(buffer, 5 + (statsWidth-10)*2/3, statsHeight - 5);
+  fl_draw(siPrefix(self->stats[statsCount-1].bps * 8, "bps").c_str(),
+          5 + (statsWidth-10)*2/3, statsHeight - 5);
 
   image = surface->image();
   delete surface;

vncviewer/UserDialog.cxx

 #include <FL/Fl_Return_Button.H>
 #include <FL/Fl_Pixmap.H>
 
-#include <rfb/util.h>
 #include <rfb/Password.h>
 #include <rfb/Exception.h>
 
 {
 }
 
-void UserDialog::getUserPasswd(bool secure, char** user, char** password)
+void UserDialog::getUserPasswd(bool secure, std::string* user,
+                               std::string* password)
 {
   const char *passwordFileName(passwordFile);
 
   char *envPassword = getenv("VNC_PASSWORD");
 
   if(user && envUsername && envPassword) {
-    *user = strdup(envUsername);
-    *password = strdup(envPassword);
+    *user = envUsername;
+    *password = envPassword;
     return;
   }
 
   if (!user && envPassword) {
-    *password = strdup(envPassword);
+    *password = envPassword;
     return;
   }
 
     fclose(fp);
 
     PlainPasswd passwd(obfPwd);
-    *password = passwd.takeBuf();
+    *password = passwd.buf;
 
     return;
   }
 
   if (ret_val == 0) {
     if (user)
-      *user = strDup(username->value());
-    *password = strDup(passwd->value());
+      *user = username->value();
+    *password = passwd->value();
   }
 
   delete win;

vncviewer/UserDialog.h

 
   // UserPasswdGetter callbacks
 
-  void getUserPasswd(bool secure, char** user, char** password);
+  void getUserPasswd(bool secure, std::string* user,
+                     std::string* password);
 
   // UserMsgBox callbacks
 

vncviewer/Viewport.cxx

 
 int Viewport::handle(int event)
 {
-  char *filtered;
+  std::string filtered;
   int buttonMask, wheelMask;
   DownMap::const_iterator iter;
 
   case FL_PASTE:
     filtered = convertLF(Fl::event_text(), Fl::event_length());
 
-    vlog.debug("Sending clipboard data (%d bytes)", (int)strlen(filtered));
+    vlog.debug("Sending clipboard data (%d bytes)", (int)filtered.size());
 
     try {
-      cc->sendClipboardData(filtered);
+      cc->sendClipboardData(filtered.c_str());
     } catch (rdr::Exception& e) {
       vlog.error("%s", e.str());
       abort_connection_with_unexpected_error(e);
     }
 
-    strFree(filtered);
-
     return 1;
 
   case FL_ENTER:

win/rfb_win32/Clipboard.cxx

   return MsgWindow::processMessage(msg, wParam, lParam);
 };
 
-char*
+std::string
 Clipboard::getClipText() {
   HGLOBAL cliphandle;
   wchar_t* clipdata;
-  CharArray utf8;
+  std::string utf8;
 
   // Open the clipboard
   if (!OpenClipboard(getHandle()))
   }
 
   // Convert it to UTF-8
-  utf8.replaceBuf(utf16ToUTF8(clipdata));
+  utf8 = utf16ToUTF8(clipdata);
 
   // Release the buffer and close the clipboard
   GlobalUnlock(cliphandle);
   CloseClipboard();
 
-  return convertLF(utf8.buf);
+  return convertLF(utf8.c_str());
 }
 
 void
       throw rdr::SystemException("unable to open Win32 clipboard", GetLastError());
 
     // - Convert the supplied clipboard text into UTF-16 format with CRLF
-    CharArray filtered(convertCRLF(text));
-    wchar_t* utf16;
-
-    utf16 = utf8ToUTF16(filtered.buf);
+    std::string filtered(convertCRLF(text));
+    std::wstring utf16(utf8ToUTF16(filtered.c_str()));
 
     // - Allocate global memory for the data
-    clip_handle = ::GlobalAlloc(GMEM_MOVEABLE, (wcslen(utf16) + 1) * 2);
+    clip_handle = ::GlobalAlloc(GMEM_MOVEABLE, (utf16.size() + 1) * 2);
 
     wchar_t* data = (wchar_t*) GlobalLock(clip_handle);
-    wcscpy(data, utf16);
+    wcscpy(data, utf16.c_str());
     GlobalUnlock(clip_handle);
 
-    strFree(utf16);
-
     // - Next, we must clear out any existing data
     if (!EmptyClipboard())
       throw rdr::SystemException("unable to empty Win32 clipboard", GetLastError());

win/rfb_win32/Clipboard.h

       void setNotifier(Notifier* cbn) {notifier = cbn;}
 
       // - Get the clipboard contents
-      char* getClipText();
+      std::string getClipText();
 
       // - Set the clipboard contents
       void setClipText(const char* text);

win/rfb_win32/RegConfig.cxx

 
 #include <rfb_win32/RegConfig.h>
 #include <rfb/LogWriter.h>
-#include <rfb/util.h>
 //#include <rdr/HexOutStream.h>
 
 using namespace rfb;
     while (1) {
       const char *name = key.getValueName(i++);
       if (!name) break;
-      CharArray value(key.getRepresentation(name));
-      if (!value.buf || !Configuration::setParam(name, value.buf))
+      std::string value = key.getRepresentation(name);
+      if (!Configuration::setParam(name, value.c_str()))
         vlog.info("unable to process %s", name);
     }
   } catch (rdr::SystemException& e) {

win/rfb_win32/Registry.cxx

   setInt(valname, value ? 1 : 0);
 }
 
-char* RegKey::getString(const char* valname) const {return getRepresentation(valname);}
-char* RegKey::getString(const char* valname, const char* def) const {
+std::string RegKey::getString(const char* valname) const {
+  return getRepresentation(valname);
+}
+
+std::string RegKey::getString(const char* valname, const char* def) const {
   try {
     return getString(valname);
   } catch(rdr::Exception&) {
-    return strDup(def);
+    return def;
   }
 }
 
 std::vector<uint8_t> RegKey::getBinary(const char* valname) const {
-  CharArray hex(getRepresentation(valname));
-  return hexToBin(hex.buf, strlen(hex.buf));
+  std::string hex = getRepresentation(valname);
+  return hexToBin(hex.data(), hex.size());
 }
 std::vector<uint8_t> RegKey::getBinary(const char* valname, const uint8_t* def, size_t deflen) const {
   try {
 }
 
 int RegKey::getInt(const char* valname) const {
-  CharArray tmp(getRepresentation(valname));
-  return atoi(tmp.buf);
+  return atoi(getRepresentation(valname).c_str());
 }
 int RegKey::getInt(const char* valname, int def) const {
   try {
   return getInt(valname, def ? 1 : 0) > 0;
 }
 
-static inline char* terminateData(char* data, int length)
-{
-  // We must terminate the string, just to be sure.  Stupid Win32...
-  int len = length/sizeof(char);
-  CharArray str(len+1);
-  memcpy(str.buf, data, length);
-  str.buf[len] = 0;
-  return str.takeBuf();
-}
-
-char* RegKey::getRepresentation(const char* valname) const {
+std::string RegKey::getRepresentation(const char* valname) const {
   DWORD type, length;
   LONG result = RegQueryValueEx(key, valname, 0, &type, 0, &length);
   if (result != ERROR_SUCCESS)
   switch (type) {
   case REG_BINARY:
     {
-      CharArray hex(binToHex((const uint8_t*)data.buf, length));
-      return hex.takeBuf();
+      return binToHex((const uint8_t*)data.buf, length);
     }
   case REG_SZ:
     if (length) {
-      return terminateData(data.buf, length);
+      return std::string(data.buf, length);
     } else {
-      return strDup("");
+      return "";
     }
   case REG_DWORD:
     {
-      CharArray tmp(16);
-      sprintf(tmp.buf, "%lu", *((DWORD*)data.buf));
-      return tmp.takeBuf();
+      char tmp[16];
+      sprintf(tmp, "%lu", *((DWORD*)data.buf));
+      return tmp;
     }
   case REG_EXPAND_SZ:
     {
     if (length) {
-      CharArray str(terminateData(data.buf, length));
-      DWORD required = ExpandEnvironmentStrings(str.buf, 0, 0);
+      std::string str(data.buf, length);
+      DWORD required = ExpandEnvironmentStrings(str.c_str(), 0, 0);
       if (required==0)
         throw rdr::SystemException("ExpandEnvironmentStrings", GetLastError());
       CharArray result(required);
-      length = ExpandEnvironmentStrings(str.buf, result.buf, required);
+      length = ExpandEnvironmentStrings(str.c_str(), result.buf, required);
       if (required<length)
         throw rdr::Exception("unable to expand environment strings");
-      return result.takeBuf();
+      return result.buf;
     } else {
-      return strDup("");
+      return "";
     }
     }
   default:
 
 bool RegKey::isValue(const char* valname) const {
   try {
-    CharArray tmp(getRepresentation(valname));
+    getRepresentation(valname);
     return true;
   } catch(rdr::Exception&) {
     return false;

win/rfb_win32/Registry.h

       void setInt(const char* valname, int i) const;
       void setBool(const char* valname, bool b) const;
 
-      char* getString(const char* valname) const;
-      char* getString(const char* valname, const char* def) const;
+      std::string getString(const char* valname) const;
+      std::string getString(const char* valname, const char* def) const;
 
       std::vector<uint8_t> getBinary(const char* valname) const;
       std::vector<uint8_t> getBinary(const char* valname, const uint8_t* def, size_t deflength) const;
       bool getBool(const char* valname) const;
       bool getBool(const char* valname, bool def) const;
 
-      char* getRepresentation(const char* valname) const;
+      std::string getRepresentation(const char* valname) const;
 
       bool isValue(const char* valname) const;
 

win/rfb_win32/SDisplay.cxx

 
 
 void SDisplay::handleClipboardRequest() {
-  CharArray data(clipboard->getClipText());
-  server->sendClipboardData(data.buf);
+  server->sendClipboardData(clipboard->getClipText().c_str());
 }
 
 void SDisplay::handleClipboardAnnounce(bool available) {

win/rfb_win32/Win32Util.cxx

     langId = langId >> 8;
   }
 
-  CharArray langIdStr(binToHex(langIdBuf, sizeof(langId)));
-  CharArray infoName(strlen("StringFileInfo") + 4 + strlen(name) + strlen(langIdStr.buf));
-  sprintf(infoName.buf, "\\StringFileInfo\\%s\\%s", langIdStr.buf, name);
+  std::string langIdStr(binToHex(langIdBuf, sizeof(langId)));
+  CharArray infoName(strlen("StringFileInfo") + 4 + strlen(name) + strlen(langIdStr.c_str()));
+  sprintf(infoName.buf, "\\StringFileInfo\\%s\\%s", langIdStr.c_str(), name);
 
   // Locate the required version string within the version info
   char* buffer = 0;

win/vncconfig/Authentication.h

 
 #ifdef HAVE_GNUTLS
         if (isItemChecked(IDC_ENC_X509)) {
-          SSecurityTLS::X509_CertFile.setParam(regKey.getString("X509Cert"));
-          SSecurityTLS::X509_CertFile.setParam(regKey.getString("X509Key"));
+          SSecurityTLS::X509_CertFile.setParam(regKey.getString("X509Cert").c_str());
+          SSecurityTLS::X509_CertFile.setParam(regKey.getString("X509Key").c_str());
         }
 #endif
 

win/vncconfig/Connections.h

 
         try {
           network::TcpFilter::Pattern pat(network::TcpFilter::parsePattern(newPat.buf));
-          pattern.replaceBuf(CharArray(network::TcpFilter::patternToStr(pat)).takeBuf());
+          pattern.replaceBuf(strDup(network::TcpFilter::patternToStr(pat).c_str()));
         } catch(rdr::Exception& e) {
           MsgBox(NULL, e.str(), MB_ICONEXCLAMATION | MB_OK);
           return false;
           SendMessage(listBox, LB_DELETESTRING, 0, 0);
 
         CharArray tmp;
-        tmp.buf = hosts.getData();
+        tmp.buf = strDup(hosts.getValueStr().c_str());
         while (tmp.buf) {
           CharArray first;
           strSplit(tmp.buf, ',', &first.buf, &tmp.buf);
         regKey.setInt("PortNumber", isItemChecked(IDC_RFB_ENABLE) ? getItemInt(IDC_PORT) : 0);
         regKey.setInt("IdleTimeout", getItemInt(IDC_IDLE_TIMEOUT));
         regKey.setInt("LocalHost", isItemChecked(IDC_LOCALHOST));
-        regKey.setString("Hosts", CharArray(getHosts()).buf);
+        regKey.setString("Hosts", getHosts().c_str());
         return true;
       }
       bool isChanged() {
         try {
-          CharArray new_hosts(getHosts());
-          return (strcmp(new_hosts.buf, hosts) != 0) ||
+          std::string new_hosts = getHosts();
+          return (new_hosts != (const char*)hosts) ||
               (localHost != isItemChecked(IDC_LOCALHOST)) ||
               (port_number != getItemInt(IDC_PORT)) ||
               (rfb::Server::idleTimeout != getItemInt(IDC_IDLE_TIMEOUT));
           return false;
         }
       }
-      char* getHosts() {
+      std::string getHosts() {
         int bufLen = 1, i;
         HWND listBox = GetDlgItem(handle, IDC_HOSTS);
         for (i=0; i<SendMessage(listBox, LB_GETCOUNT, 0, 0); i++)
           bufLen+=SendMessage(listBox, LB_GETTEXTLEN, i, 0)+1;
-        CharArray hosts_str(bufLen);
-        hosts_str.buf[0] = 0;
-        char* outPos = hosts_str.buf;
+        std::vector<char> hosts_str(bufLen);
+        hosts_str[0] = 0;
+        char* outPos = hosts_str.data();
         for (i=0; i<SendMessage(listBox, LB_GETCOUNT, 0, 0); i++) {
           outPos += SendMessage(listBox, LB_GETTEXT, i, (LPARAM)outPos);
           outPos[0] = ',';
           outPos[1] = 0;
           outPos++;
         }
-        return strDup(hosts_str.buf);
+        return hosts_str.data();
       }
 
     protected:

win/vncconfig/Legacy.cxx

             regKey.setString("Log", logSetting);
           }
  
-          CharArray authHosts;
-          authHosts.buf = winvnc3.getString("AuthHosts", 0);
-          if (authHosts.buf) {
+          std::string authHosts = winvnc3.getString("AuthHosts", "");
+          if (!authHosts.empty()) {
             CharArray newHosts;
             newHosts.buf = strDup("");
 
             // Reformat AuthHosts to Hosts.  Wish I'd left the format the same. :( :( :(
             try {
-              CharArray tmp(authHosts.buf);
+              CharArray tmp(strDup(authHosts.c_str()));
               while (tmp.buf) {
 
                 // Split the AuthHosts string into patterns to match

win/winvnc/VNCServerWin32.cxx

     prefix = "VNC Server (Service):";
 
   // Fetch the list of addresses
-  std::list<char*> addrs;
+  std::list<std::string> addrs;
   if (rfbSock.isListening())
-    TcpListener::getMyAddresses(&addrs);
+    addrs = TcpListener::getMyAddresses();
   else
-    addrs.push_front(strDup("Not accepting connections"));
+    addrs.push_front("Not accepting connections");
 
   // Allocate space for the new tip
-  std::list<char*>::iterator i, next_i;
+  std::list<std::string>::iterator i, next_i;
   int length = strlen(prefix)+1;
   for (i=addrs.begin(); i!= addrs.end(); i++)
-    length += strlen(*i) + 1;
+    length += i->size() + 1;
 
   // Build the new tip
   CharArray toolTip(length);
   strcpy(toolTip.buf, prefix);
   for (i=addrs.begin(); i!= addrs.end(); i=next_i) {
     next_i = i; next_i ++;
-    CharArray addr(*i);    // Assumes ownership of string
-    strcat(toolTip.buf, addr.buf);
+    strcat(toolTip.buf, i->c_str());
     if (next_i != addrs.end())
       strcat(toolTip.buf, ",");
   }
 bool VNCServerWin32::addNewClient(const char* client) {
   TcpSocket* sock = 0;
   try {
-    CharArray hostname;
+    std::string hostname;
     int port;
-    getHostAndPort(client, &hostname.buf, &port, 5500);
+    getHostAndPort(client, &hostname, &port, 5500);
     vlog.error("port=%d", port);
-    sock = new TcpSocket(hostname.buf, port);
+    sock = new TcpSocket(hostname.c_str(), port);
     if (queueCommand(AddClient, sock, 0))
       return true;
     delete sock;