Use static string for exceptions

In preparation for using the built in C++ exception classes, which do
not accept a format string.

diff --git a/common/network/TcpSocket.cxx b/common/network/TcpSocket.cxx
index 3f2f0f1fdc9f2fdc6ffd5076f0930a65dc411cec..38cb6eb386275fc6c1da693c624c149e7832a9e9 100644 (file)
--- a/common/network/TcpSocket.cxx
+++ b/common/network/TcpSocket.cxx
@@ -663,8 +663,8 @@ TcpFilter::Pattern TcpFilter::parsePattern(const char* p) {
   family = pattern.address.u.sa.sa_family;
 
   if (pattern.prefixlen > (family == AF_INET ? 32: 128))
-    throw Exception("invalid prefix length for filter address: %u",
-                    pattern.prefixlen);
+    throw Exception(rfb::format("invalid prefix length for filter address: %u",
+                                pattern.prefixlen));
 
   // Compute mask from address and prefix length
   memset (&pattern.mask, 0, sizeof (pattern.mask));

diff --git a/common/rdr/BufferedInStream.cxx b/common/rdr/BufferedInStream.cxx
index 3c04bafc34ca9c3fbd6bfbe6fa06166e6f3b1b06..204202eca593a22f4120aead80c1def0ca17f542 100644 (file)
--- a/common/rdr/BufferedInStream.cxx
+++ b/common/rdr/BufferedInStream.cxx
@@ -26,6 +26,8 @@
 #include <rdr/BufferedInStream.h>
 #include <rdr/Exception.h>
 
+#include <rfb/util.h>
+
 using namespace rdr;
 
 static const size_t DEFAULT_BUF_SIZE = 8192;
@@ -63,9 +65,10 @@ void BufferedInStream::ensureSpace(size_t needed)
     uint8_t* newBuffer;
 
     if (needed > MAX_BUF_SIZE)
-      throw Exception("BufferedInStream overrun: requested size of "
-                      "%lu bytes exceeds maximum of %lu bytes",
-                      (long unsigned)needed, (long unsigned)MAX_BUF_SIZE);
+      throw Exception(rfb::format("BufferedInStream overrun: requested "
+                                  "size of %lu bytes exceeds maximum "
+                                  "of %lu bytes", (long unsigned)needed,
+                                  (long unsigned)MAX_BUF_SIZE));
 
     newSize = DEFAULT_BUF_SIZE;
     while (newSize < needed)

diff --git a/common/rdr/BufferedOutStream.cxx b/common/rdr/BufferedOutStream.cxx
index 0d6a1eb6b084d0e998010f36751824f64473334e..f5062bf2cecffade96db9d10d4daa127fd9ecb41 100644 (file)
--- a/common/rdr/BufferedOutStream.cxx
+++ b/common/rdr/BufferedOutStream.cxx
@@ -25,6 +25,7 @@
 #include <rdr/BufferedOutStream.h>
 #include <rdr/Exception.h>
 
+#include <rfb/util.h>
 
 using namespace rdr;
 
@@ -138,10 +139,10 @@ void BufferedOutStream::overrun(size_t needed)
   // We'll need to allocate more buffer space...
 
   if (totalNeeded > MAX_BUF_SIZE)
-    throw Exception("BufferedOutStream overrun: requested size of "
-                    "%lu bytes exceeds maximum of %lu bytes",
-                    (long unsigned)totalNeeded,
-                    (long unsigned)MAX_BUF_SIZE);
+    throw Exception(rfb::format("BufferedOutStream overrun: requested "
+                                "size of %lu bytes exceeds maximum of "
+                                "%lu bytes", (long unsigned)totalNeeded,
+                                (long unsigned)MAX_BUF_SIZE));
 
   newSize = DEFAULT_BUF_SIZE;
   while (newSize < totalNeeded)

diff --git a/common/rdr/Exception.cxx b/common/rdr/Exception.cxx
index 4c99d9774830eb1efc11bafd306f10d1750d8021..277da53303b97f9235c33ad6b5966786b763b316 100644 (file)
--- a/common/rdr/Exception.cxx
+++ b/common/rdr/Exception.cxx
@@ -44,16 +44,19 @@
 
 using namespace rdr;
 
-Exception::Exception(const char *format, ...) {
-       va_list ap;
+Exception::Exception(const char *message)
+{
+  snprintf(str_, len, "%s", message);
+}
 
-       va_start(ap, format);
-       (void) vsnprintf(str_, len, format, ap);
-       va_end(ap);
+Exception::Exception(const std::string& message)
+{
+  snprintf(str_, len, "%s", message.c_str());
 }
 
+
 GAIException::GAIException(const char* s, int err_)
-  : Exception("%s", s), err(err_)
+  : Exception(s), err(err_)
 {
   strncat(str_, ": ", len-1-strlen(str_));
 #ifdef _WIN32
@@ -78,7 +81,7 @@ GAIException::GAIException(const char* s, int err_)
 }
 
 PosixException::PosixException(const char* s, int err_)
-  : Exception("%s", s), err(err_)
+  : Exception(s), err(err_)
 {
   strncat(str_, ": ", len-1-strlen(str_));
 #ifdef _WIN32
@@ -99,7 +102,7 @@ PosixException::PosixException(const char* s, int err_)
 
 #ifdef WIN32
 Win32Exception::Win32Exception(const char* s, unsigned err_)
-  : Exception("%s", s), err(err_)
+  : Exception(s), err(err_)
 {
   strncat(str_, ": ", len-1-strlen(str_));
   wchar_t *currStr = new wchar_t[len-strlen(str_)];

diff --git a/common/rdr/Exception.h b/common/rdr/Exception.h
index c59f7e55001f183ecd341a8ced66e4360269daaf..65d3d90af51af6bd40622f6fcb2f8586512977a9 100644 (file)
--- a/common/rdr/Exception.h
+++ b/common/rdr/Exception.h
@@ -21,13 +21,15 @@
 #ifndef __RDR_EXCEPTION_H__
 #define __RDR_EXCEPTION_H__
 
+#include <string>
+
 namespace rdr {
 
   struct Exception {
     enum { len = 256 };
     char str_[len];
-    Exception(const char *format=nullptr, ...)
-      __attribute__((__format__ (__printf__, 2, 3)));
+    Exception(const char* message);
+    Exception(const std::string& message);
     virtual ~Exception() {}
     virtual const char* str() const { return str_; }
   };

diff --git a/common/rdr/TLSException.cxx b/common/rdr/TLSException.cxx
index 0f75a4dacc3b4ad34ee545113bfec431177c42d6..df2701d3725fee2021cf88c7694c1cd538e7a7b0 100644 (file)
--- a/common/rdr/TLSException.cxx
+++ b/common/rdr/TLSException.cxx
@@ -24,6 +24,8 @@
 
 #include <rdr/TLSException.h>
 
+#include <rfb/util.h>
+
 #include <string.h>
 #include <stdio.h>
 #ifdef HAVE_GNUTLS
@@ -34,7 +36,8 @@ using namespace rdr;
 
 #ifdef HAVE_GNUTLS
 TLSException::TLSException(const char* s, int err_)
-  : Exception("%s: %s (%d)", s, gnutls_strerror(err_), err_), err(err_)
+  : Exception(rfb::format("%s: %s (%d)", s, gnutls_strerror(err_), err_)),
+    err(err_)
 {
 }
 #endif /* HAVE_GNUTLS */

diff --git a/common/rfb/CConnection.cxx b/common/rfb/CConnection.cxx
index b4017dba8e658c832e4ff778f4fc51a1e31c4f87..61ef7d98eba5ae0a76f4226c5ea5212e0a438e5c 100644 (file)
--- a/common/rfb/CConnection.cxx
+++ b/common/rfb/CConnection.cxx
@@ -185,8 +185,8 @@ bool CConnection::processVersionMsg()
     vlog.error("Server gave unsupported RFB protocol version %d.%d",
                server.majorVersion, server.minorVersion);
     state_ = RFBSTATE_INVALID;
-    throw Exception("Server gave unsupported RFB protocol version %d.%d",
-                    server.majorVersion, server.minorVersion);
+    throw Exception(format("Server gave unsupported RFB protocol version %d.%d",
+                           server.majorVersion, server.minorVersion));
   } else if (server.beforeVersion(3,7)) {
     server.setVersion(3,3);
   } else if (server.afterVersion(3,8)) {

diff --git a/common/rfb/CMsgReader.cxx b/common/rfb/CMsgReader.cxx
index 8bcdbfd04e2fa06ffbe2c8ad4a9a9bc69f6f1ff3..c94ecfd8c421af8a33b8fcdf9b7d8b07a25e6bb7 100644 (file)
--- a/common/rfb/CMsgReader.cxx
+++ b/common/rfb/CMsgReader.cxx
@@ -119,7 +119,7 @@ bool CMsgReader::readMsg()
       ret = readEndOfContinuousUpdates();
       break;
     default:
-      throw Exception("Unknown message type %d", currentMsgType);
+      throw Exception(format("Unknown message type %d", currentMsgType));
     }
 
     if (ret)

diff --git a/common/rfb/CSecurityTLS.cxx b/common/rfb/CSecurityTLS.cxx
index 6eeb6a84d3c65af9dad861cf25a3c4d5b35679ec..8f2ec0338323f89cbd10d7c169565c6590a68f25 100644 (file)
--- a/common/rfb/CSecurityTLS.cxx
+++ b/common/rfb/CSecurityTLS.cxx
@@ -344,7 +344,8 @@ void CSecurityTLS::checkSession()
 
       gnutls_free(status_str.data);
 
-      throw Exception("Invalid server certificate: %s", error.c_str());
+      throw Exception(format("Invalid server certificate: %s",
+                             error.c_str()));
     }
 
     err = gnutls_certificate_verification_status_print(status,

diff --git a/common/rfb/ClientParams.cxx b/common/rfb/ClientParams.cxx
index bc20c3d7261a965eb7a1e4521349aec0732cd0fe..3f80f10954a237f71bf228a27bb03217d4d6ded8 100644 (file)
--- a/common/rfb/ClientParams.cxx
+++ b/common/rfb/ClientParams.cxx
@@ -27,6 +27,7 @@
 #include <rfb/ledStates.h>
 #include <rfb/clipboardTypes.h>
 #include <rfb/ClientParams.h>
+#include <rfb/util.h>
 
 using namespace rfb;
 
@@ -160,7 +161,7 @@ uint32_t ClientParams::clipboardSize(unsigned int format) const
       return clipSizes[i];
   }
 
-  throw Exception("Invalid clipboard format 0x%x", format);
+  throw Exception(rfb::format("Invalid clipboard format 0x%x", format));
 }
 
 void ClientParams::setClipboardCaps(uint32_t flags, const uint32_t* lengths)

diff --git a/common/rfb/DecodeManager.cxx b/common/rfb/DecodeManager.cxx
index ef415886114aa7c6ef98b4cb63d3e1311848d6c8..269e818d08ad596da8029f8c113bda57d89d2688 100644 (file)
--- a/common/rfb/DecodeManager.cxx
+++ b/common/rfb/DecodeManager.cxx
@@ -149,7 +149,7 @@ bool DecodeManager::decodeRect(const Rect& r, int encoding,
     if (!decoder->readRect(r, conn->getInStream(), conn->server, bufferStream))
       return false;
   } catch (rdr::Exception& e) {
-    throw Exception("Error reading rect: %s", e.str());
+    throw Exception(format("Error reading rect: %s", e.str()));
   }
 
   stats[encoding].rects++;
@@ -250,7 +250,7 @@ void DecodeManager::setThreadException(const rdr::Exception& e)
   if (threadException != nullptr)
     return;
 
-  threadException = new rdr::Exception("Exception on worker thread: %s", e.str());
+  threadException = new rdr::Exception(format("Exception on worker thread: %s", e.str()));
 }
 
 void DecodeManager::throwThreadException()

diff --git a/common/rfb/Exception.h b/common/rfb/Exception.h
index 773c65fae92e5720f8af579528a37dce63f58b75..3c8a461c02f60bbc399f5d5d7c419cd13b5b9674 100644 (file)
--- a/common/rfb/Exception.h
+++ b/common/rfb/Exception.h
@@ -24,7 +24,9 @@ namespace rfb {
   typedef rdr::Exception Exception;
   struct AuthFailureException : public Exception {
     AuthFailureException(const char* reason)
-      : Exception("%s", reason) {}
+      : Exception(reason) {}
+    AuthFailureException(std::string& reason)
+      : Exception(reason) {}
   };
   struct AuthCancelledException : public rfb::Exception {
     AuthCancelledException()

diff --git a/common/rfb/JpegCompressor.cxx b/common/rfb/JpegCompressor.cxx
index 42d5c475bf16c5612acd28ab1505a76d4d87c076..49ed4b61eadf9299bb718017bbcbf720319d9a61 100644 (file)
--- a/common/rfb/JpegCompressor.cxx
+++ b/common/rfb/JpegCompressor.cxx
@@ -127,7 +127,7 @@ JpegCompressor::JpegCompressor(int bufferLen) : MemOutStream(bufferLen)
 
   if(setjmp(err->jmpBuffer)) {
     // this will execute if libjpeg has an error
-    throw rdr::Exception("%s", err->lastError);
+    throw rdr::Exception(err->lastError);
   }
 
   jpeg_create_compress(cinfo);
@@ -171,7 +171,7 @@ void JpegCompressor::compress(const uint8_t *buf, volatile int stride,
     jpeg_abort_compress(cinfo);
     if (srcBufIsTemp && srcBuf) delete[] srcBuf;
     if (rowPointer) delete[] rowPointer;
-    throw rdr::Exception("%s", err->lastError);
+    throw rdr::Exception(err->lastError);
   }
 
   cinfo->image_width = w;

diff --git a/common/rfb/JpegDecompressor.cxx b/common/rfb/JpegDecompressor.cxx
index 92ef014faf69138fd0b1c524b0a34640951a0df9..4b3b4db7fec05aae802dd2b2d438bd9c23becf7f 100644 (file)
--- a/common/rfb/JpegDecompressor.cxx
+++ b/common/rfb/JpegDecompressor.cxx
@@ -120,7 +120,7 @@ JpegDecompressor::JpegDecompressor(void)
 
   if(setjmp(err->jmpBuffer)) {
     // this will execute if libjpeg has an error
-    throw rdr::Exception("%s", err->lastError);
+    throw rdr::Exception(err->lastError);
   }
 
   jpeg_create_decompress(dinfo);
@@ -168,7 +168,7 @@ void JpegDecompressor::decompress(const uint8_t *jpegBuf,
     jpeg_abort_decompress(dinfo);
     if (dstBufIsTemp && dstBuf) delete[] dstBuf;
     if (rowPointer) delete[] rowPointer;
-    throw rdr::Exception("%s", err->lastError);
+    throw rdr::Exception(err->lastError);
   }
 
   src->pub.next_input_byte = jpegBuf;

diff --git a/common/rfb/PixelBuffer.cxx b/common/rfb/PixelBuffer.cxx
index 0a287544bc9d35955e7d31470d380e4373a8a62a..ca2a584502f948bacf20f6e065da6f5a09f8cfb5 100644 (file)
--- a/common/rfb/PixelBuffer.cxx
+++ b/common/rfb/PixelBuffer.cxx
@@ -31,6 +31,7 @@
 #include <rfb/Exception.h>
 #include <rfb/LogWriter.h>
 #include <rfb/PixelBuffer.h>
+#include <rfb/util.h>
 
 using namespace rfb;
 
@@ -70,9 +71,10 @@ PixelBuffer::getImage(void* imageBuf, const Rect& r, int outStride) const
   const uint8_t* end;
 
   if (!r.enclosed_by(getRect()))
-    throw rfb::Exception("Source rect %dx%d at %d,%d exceeds framebuffer %dx%d",
-                         r.width(), r.height(),
-                         r.tl.x, r.tl.y, width(), height());
+    throw rfb::Exception(rfb::format("Source rect %dx%d at %d,%d exceeds framebuffer %dx%d",
+                                     r.width(), r.height(),
+                                     r.tl.x, r.tl.y,
+                                     width(), height()));
 
   data = getBuffer(r, &inStride);
 
@@ -106,9 +108,10 @@ void PixelBuffer::getImage(const PixelFormat& pf, void* imageBuf,
   }
 
   if (!r.enclosed_by(getRect()))
-    throw rfb::Exception("Source rect %dx%d at %d,%d exceeds framebuffer %dx%d",
-                         r.width(), r.height(),
-                         r.tl.x, r.tl.y, width(), height());
+    throw rfb::Exception(rfb::format("Source rect %dx%d at %d,%d exceeds framebuffer %dx%d",
+                                     r.width(), r.height(),
+                                     r.tl.x, r.tl.y,
+                                     width(), height()));
 
   if (stride == 0)
     stride = r.width();
@@ -122,9 +125,9 @@ void PixelBuffer::getImage(const PixelFormat& pf, void* imageBuf,
 void PixelBuffer::setSize(int width, int height)
 {
   if ((width < 0) || (width > maxPixelBufferWidth))
-    throw rfb::Exception("Invalid PixelBuffer width of %d pixels requested", width);
+    throw rfb::Exception(rfb::format("Invalid PixelBuffer width of %d pixels requested", width));
   if ((height < 0) || (height > maxPixelBufferHeight))
-    throw rfb::Exception("Invalid PixelBuffer height of %d pixels requested", height);
+    throw rfb::Exception(rfb::format("Invalid PixelBuffer height of %d pixels requested", height));
 
   width_ = width;
   height_ = height;
@@ -153,8 +156,10 @@ void ModifiablePixelBuffer::fillRect(const Rect& r, const void* pix)
   int w, h, b;
 
   if (!r.enclosed_by(getRect()))
-    throw rfb::Exception("Destination rect %dx%d at %d,%d exceeds framebuffer %dx%d",
-                         r.width(), r.height(), r.tl.x, r.tl.y, width(), height());
+    throw rfb::Exception(rfb::format("Destination rect %dx%d at %d,%d exceeds framebuffer %dx%d",
+                                     r.width(), r.height(),
+                                     r.tl.x, r.tl.y,
+                                     width(), height()));
 
   w = r.width();
   h = r.height();
@@ -203,9 +208,10 @@ void ModifiablePixelBuffer::imageRect(const Rect& r,
   uint8_t* end;
 
   if (!r.enclosed_by(getRect()))
-    throw rfb::Exception("Destination rect %dx%d at %d,%d exceeds framebuffer %dx%d",
-                         r.width(), r.height(),
-                         r.tl.x, r.tl.y, width(), height());
+    throw rfb::Exception(rfb::format("Destination rect %dx%d at %d,%d exceeds framebuffer %dx%d",
+                                     r.width(), r.height(),
+                                     r.tl.x, r.tl.y,
+                                     width(), height()));
 
   bytesPerPixel = getPF().bpp/8;
 
@@ -242,15 +248,17 @@ void ModifiablePixelBuffer::copyRect(const Rect &rect,
 
   drect = rect;
   if (!drect.enclosed_by(getRect()))
-    throw rfb::Exception("Destination rect %dx%d at %d,%d exceeds framebuffer %dx%d",
-                         drect.width(), drect.height(),
-                         drect.tl.x, drect.tl.y, width(), height());
+    throw rfb::Exception(rfb::format("Destination rect %dx%d at %d,%d exceeds framebuffer %dx%d",
+                                     drect.width(), drect.height(),
+                                     drect.tl.x, drect.tl.y,
+                                     width(), height()));
 
   srect = drect.translate(move_by_delta.negate());
   if (!srect.enclosed_by(getRect()))
-    throw rfb::Exception("Source rect %dx%d at %d,%d exceeds framebuffer %dx%d",
-                         srect.width(), srect.height(),
-                         srect.tl.x, srect.tl.y, width(), height());
+    throw rfb::Exception(rfb::format("Source rect %dx%d at %d,%d exceeds framebuffer %dx%d",
+                                     srect.width(), srect.height(),
+                                     srect.tl.x, srect.tl.y,
+                                     width(), height()));
 
   bytesPerPixel = format.bpp/8;
 
@@ -303,9 +311,10 @@ void ModifiablePixelBuffer::imageRect(const PixelFormat& pf, const Rect &dest,
   int dstStride;
 
   if (!dest.enclosed_by(getRect()))
-    throw rfb::Exception("Destination rect %dx%d at %d,%d exceeds framebuffer %dx%d",
-                         dest.width(), dest.height(),
-                         dest.tl.x, dest.tl.y, width(), height());
+    throw rfb::Exception(rfb::format("Destination rect %dx%d at %d,%d exceeds framebuffer %dx%d",
+                                     dest.width(), dest.height(),
+                                     dest.tl.x, dest.tl.y,
+                                     width(), height()));
 
   if (stride == 0)
     stride = dest.width();
@@ -332,9 +341,10 @@ FullFramePixelBuffer::~FullFramePixelBuffer() {}
 uint8_t* FullFramePixelBuffer::getBufferRW(const Rect& r, int* stride_)
 {
   if (!r.enclosed_by(getRect()))
-    throw rfb::Exception("Pixel buffer request %dx%d at %d,%d exceeds framebuffer %dx%d",
-                         r.width(), r.height(),
-                         r.tl.x, r.tl.y, width(), height());
+    throw rfb::Exception(rfb::format("Pixel buffer request %dx%d at %d,%d exceeds framebuffer %dx%d",
+                                     r.width(), r.height(),
+                                     r.tl.x, r.tl.y,
+                                     width(), height()));
 
   *stride_ = stride;
   return &data[(r.tl.x + (r.tl.y * stride)) * (format.bpp/8)];
@@ -347,9 +357,10 @@ void FullFramePixelBuffer::commitBufferRW(const Rect& /*r*/)
 const uint8_t* FullFramePixelBuffer::getBuffer(const Rect& r, int* stride_) const
 {
   if (!r.enclosed_by(getRect()))
-    throw rfb::Exception("Pixel buffer request %dx%d at %d,%d exceeds framebuffer %dx%d",
-                         r.width(), r.height(),
-                         r.tl.x, r.tl.y, width(), height());
+    throw rfb::Exception(rfb::format("Pixel buffer request %dx%d at %d,%d exceeds framebuffer %dx%d",
+                                     r.width(), r.height(),
+                                     r.tl.x, r.tl.y,
+                                     width(), height()));
 
   *stride_ = stride;
   return &data[(r.tl.x + (r.tl.y * stride)) * (format.bpp/8)];
@@ -359,13 +370,13 @@ void FullFramePixelBuffer::setBuffer(int width, int height,
                                      uint8_t* data_, int stride_)
 {
   if ((width < 0) || (width > maxPixelBufferWidth))
-    throw rfb::Exception("Invalid PixelBuffer width of %d pixels requested", width);
+    throw rfb::Exception(rfb::format("Invalid PixelBuffer width of %d pixels requested", width));
   if ((height < 0) || (height > maxPixelBufferHeight))
-    throw rfb::Exception("Invalid PixelBuffer height of %d pixels requested", height);
+    throw rfb::Exception(rfb::format("Invalid PixelBuffer height of %d pixels requested", height));
   if ((stride_ < 0) || (stride_ > maxPixelBufferStride) || (stride_ < width))
-    throw rfb::Exception("Invalid PixelBuffer stride of %d pixels requested", stride_);
+    throw rfb::Exception(rfb::format("Invalid PixelBuffer stride of %d pixels requested", stride_));
   if ((width != 0) && (height != 0) && (data_ == nullptr))
-    throw rfb::Exception("PixelBuffer requested without a valid memory area");
+    throw rfb::Exception(rfb::format("PixelBuffer requested without a valid memory area"));
 
   ModifiablePixelBuffer::setSize(width, height);
   stride = stride_;

diff --git a/common/rfb/SConnection.cxx b/common/rfb/SConnection.cxx
index 905f88a43ab9a842cc7566607d2e1ebdedf7a1f6..04cf60b93720865d6106b16a025f7f9833b98935 100644 (file)
--- a/common/rfb/SConnection.cxx
+++ b/common/rfb/SConnection.cxx
@@ -133,9 +133,10 @@ bool SConnection::processVersionMsg()
 
   if (client.majorVersion != 3) {
     // unknown protocol version
-    failConnection("Client needs protocol version %d.%d, server has %d.%d",
-                   client.majorVersion, client.minorVersion,
-                   defaultMajorVersion, defaultMinorVersion);
+    failConnection(format("Client needs protocol version %d.%d, "
+                          "server has %d.%d",
+                          client.majorVersion, client.minorVersion,
+                          defaultMajorVersion, defaultMinorVersion));
   }
 
   if (client.minorVersion != 3 && client.minorVersion != 7 && client.minorVersion != 8) {
@@ -165,8 +166,9 @@ bool SConnection::processVersionMsg()
       if (*i == secTypeNone || *i == secTypeVncAuth) break;
     }
     if (i == secTypes.end()) {
-      failConnection("No supported security type for %d.%d client",
-                     client.majorVersion, client.minorVersion);
+      failConnection(format("No supported security type for "
+                            "%d.%d client",
+                            client.majorVersion, client.minorVersion));
     }
 
     os->writeU32(*i);
@@ -222,7 +224,7 @@ void SConnection::processSecurityType(int secType)
     state_ = RFBSTATE_SECURITY;
     ssecurity = security.GetSSecurity(this, secType);
   } catch (rdr::Exception& e) {
-    failConnection("%s", e.str());
+    failConnection(e.str());
   }
 }
 
@@ -299,33 +301,31 @@ void SConnection::handleAuthFailureTimeout(Timer* /*t*/)
   close(authFailureMsg.c_str());
 }
 
-void SConnection::failConnection(const char* format, ...)
+void SConnection::failConnection(const char* message)
 {
-       va_list ap;
-       char str[256];
-
-       va_start(ap, format);
-       (void) vsnprintf(str, sizeof(str), format, ap);
-       va_end(ap);
-
-  vlog.info("Connection failed: %s", str);
+  vlog.info("Connection failed: %s", message);
 
   if (state_ == RFBSTATE_PROTOCOL_VERSION) {
     if (client.majorVersion == 3 && client.minorVersion == 3) {
       os->writeU32(0);
-      os->writeU32(strlen(str));
-      os->writeBytes((const uint8_t*)str, strlen(str));
+      os->writeU32(strlen(message));
+      os->writeBytes((const uint8_t*)message, strlen(message));
       os->flush();
     } else {
       os->writeU8(0);
-      os->writeU32(strlen(str));
-      os->writeBytes((const uint8_t*)str, strlen(str));
+      os->writeU32(strlen(message));
+      os->writeBytes((const uint8_t*)message, strlen(message));
       os->flush();
     }
   }
 
   state_ = RFBSTATE_INVALID;
-  throw Exception("%s", str);
+  throw Exception(message);
+}
+
+void SConnection::failConnection(const std::string& message)
+{
+  failConnection(message.c_str());
 }
 
 void SConnection::setAccessRights(AccessRights ar)

diff --git a/common/rfb/SConnection.h b/common/rfb/SConnection.h
index 0a11f67b6c8efa293e6c892339d3b74b43150e45..886972af79ab9b8c1c3fb06fabd5c239aac813b1 100644 (file)
--- a/common/rfb/SConnection.h
+++ b/common/rfb/SConnection.h
@@ -219,8 +219,8 @@ namespace rfb {
     // failConnection() prints a message to the log, sends a connection
     // failed message to the client (if possible) and throws an
     // Exception.
-    void failConnection(const char* format, ...)
-      __attribute__((__format__ (__printf__, 2, 3)));
+    void failConnection(const char* message);
+    void failConnection(const std::string& message);
 
     void setState(stateEnum s) { state_ = s; }
 

diff --git a/common/rfb/SMsgReader.cxx b/common/rfb/SMsgReader.cxx
index 9ddea53df6bf83f213feaf1cf89ac102f1277e1a..5b1b0eaa04c42f9dc69fb9d90fe1ce162c2fc4da 100644 (file)
--- a/common/rfb/SMsgReader.cxx
+++ b/common/rfb/SMsgReader.cxx
@@ -464,7 +464,7 @@ bool SMsgReader::readQEMUMessage()
     ret = readQEMUKeyEvent();
     break;
   default:
-    throw Exception("unknown QEMU submessage type %d", subType);
+    throw Exception(format("unknown QEMU submessage type %d", subType));
   }
 
   if (!ret) {

diff --git a/common/rfb/ServerParams.cxx b/common/rfb/ServerParams.cxx
index 9f6f530764a5950bb11172d7ba4808c98faec86f..2a8d3a8ea9484688c34544814fb34c27a83c9e15 100644 (file)
--- a/common/rfb/ServerParams.cxx
+++ b/common/rfb/ServerParams.cxx
@@ -25,6 +25,7 @@
 #include <rfb/Exception.h>
 #include <rfb/ledStates.h>
 #include <rfb/ServerParams.h>
+#include <rfb/util.h>
 
 using namespace rfb;
 
@@ -99,7 +100,7 @@ uint32_t ServerParams::clipboardSize(unsigned int format) const
       return clipSizes[i];
   }
 
-  throw Exception("Invalid clipboard format 0x%x", format);
+  throw Exception(rfb::format("Invalid clipboard format 0x%x", format));
 }
 
 void ServerParams::setClipboardCaps(uint32_t flags, const uint32_t* lengths)

diff --git a/common/rfb/TightDecoder.cxx b/common/rfb/TightDecoder.cxx
index 807f71a5d87cb5fb2891705dccc0417706be5109..89d2e839681c9f9961c99e827e37a17c56f4470a 100644 (file)
--- a/common/rfb/TightDecoder.cxx
+++ b/common/rfb/TightDecoder.cxx
@@ -36,6 +36,7 @@
 #include <rfb/PixelBuffer.h>
 #include <rfb/TightConstants.h>
 #include <rfb/TightDecoder.h>
+#include <rfb/util.h>
 
 using namespace rfb;
 
@@ -110,7 +111,7 @@ bool TightDecoder::readRect(const Rect& r, rdr::InStream* is,
   int palSize = 0;
 
   if (r.width() > TIGHT_MAX_WIDTH)
-    throw Exception("TightDecoder: too large rectangle (%d pixels)", r.width());
+    throw Exception(format("TightDecoder: too large rectangle (%d pixels)", r.width()));
 
   // Possible palette
   if ((comp_ctl & tightExplicitFilter) != 0) {

diff --git a/unix/x0vncserver/XDesktop.cxx b/unix/x0vncserver/XDesktop.cxx
index fd19dd710fed37014ae874cd7eeb2765d9cc40f6..1dc76718140467d665c2cbc690698fe519f18aad 100644 (file)
--- a/unix/x0vncserver/XDesktop.cxx
+++ b/unix/x0vncserver/XDesktop.cxx
@@ -98,7 +98,7 @@ XDesktop::XDesktop(Display* dpy_, Geometry *geometry_)
   if (!XkbQueryExtension(dpy, &xkbOpcode, &xkbEventBase,
                          &xkbErrorBase, &major, &minor)) {
     vlog.error("XKEYBOARD extension not present");
-    throw Exception();
+    throw Exception("XKEYBOARD extension not present");
   }
 
   XkbSelectEvents(dpy, XkbUseCoreKbd, XkbIndicatorStateNotifyMask,

diff --git a/vncviewer/ServerDialog.cxx b/vncviewer/ServerDialog.cxx
index 8622fff186c9a11dba42eddd7ef23d1405d3747d..7b334bcaca62c53a052ecc510e5fb1b12292edea 100644 (file)
--- a/vncviewer/ServerDialog.cxx
+++ b/vncviewer/ServerDialog.cxx
@@ -382,8 +382,8 @@ void ServerDialog::loadServerHistory()
 
     if (len == (sizeof(line) - 1)) {
       fclose(f);
-      throw Exception(_("Failed to read line %d in file %s: %s"),
-                      lineNr, filepath, _("Line too long"));
+      throw Exception(format(_("Failed to read line %d in file %s: %s"),
+                             lineNr, filepath, _("Line too long")));
     }
 
     if ((len > 0) && (line[len-1] == '\n')) {

diff --git a/vncviewer/parameters.cxx b/vncviewer/parameters.cxx
index c75cad8bd3ed2cca857c4a81b3a72865c3a91ba0..2beae9304d6d14c70ec2b30b744c4bc5bed3ad33 100644 (file)
--- a/vncviewer/parameters.cxx
+++ b/vncviewer/parameters.cxx
@@ -465,8 +465,8 @@ static void saveToReg(const char* servername) {
     setKeyString("ServerName", servername, &hKey);
   } catch (Exception& e) {
     RegCloseKey(hKey);
-    throw Exception(_("Failed to save \"%s\": %s"),
-                    "ServerName", e.str());
+    throw Exception(format(_("Failed to save \"%s\": %s"),
+                           "ServerName", e.str()));
   }
 
   for (size_t i = 0; i < sizeof(parameterArray)/sizeof(VoidParameter*); i++) {
@@ -482,8 +482,8 @@ static void saveToReg(const char* servername) {
       }
     } catch (Exception& e) {
       RegCloseKey(hKey);
-      throw Exception(_("Failed to save \"%s\": %s"),
-                      parameterArray[i]->getName(), e.str());
+      throw Exception(format(_("Failed to save \"%s\": %s"),
+                             parameterArray[i]->getName(), e.str()));
     }
   }
 
@@ -495,8 +495,9 @@ static void saveToReg(const char* servername) {
       removeValue(readOnlyParameterArray[i]->getName(), &hKey);
     } catch (Exception& e) {
       RegCloseKey(hKey);
-      throw Exception(_("Failed to remove \"%s\": %s"),
-                      readOnlyParameterArray[i]->getName(), e.str());
+      throw Exception(format(_("Failed to remove \"%s\": %s"),
+                             readOnlyParameterArray[i]->getName(),
+                             e.str()));
     }
   }
 
@@ -656,8 +657,9 @@ void saveViewerParameters(const char *filename, const char *servername) {
 
   if (!encodeValue(servername, encodingBuffer, buffersize)) {
     fclose(f);
-    throw Exception(_("Failed to save \"%s\": %s"),
-                    "ServerName", _("Could not encode parameter"));
+    throw Exception(format(_("Failed to save \"%s\": %s"),
+                           "ServerName",
+                           _("Could not encode parameter")));
   }
   fprintf(f, "ServerName=%s\n", encodingBuffer);
 
@@ -666,9 +668,9 @@ void saveViewerParameters(const char *filename, const char *servername) {
       if (!encodeValue(*(StringParameter*)param,
           encodingBuffer, buffersize)) {
         fclose(f);
-        throw Exception(_("Failed to save \"%s\": %s"),
-                        param->getName(),
-                        _("Could not encode parameter"));
+        throw Exception(format(_("Failed to save \"%s\": %s"),
+                               param->getName(),
+                               _("Could not encode parameter")));
       }
       fprintf(f, "%s=%s\n", ((StringParameter*)param)->getName(), encodingBuffer);
     } else if (dynamic_cast<IntParameter*>(param) != nullptr) {
@@ -677,9 +679,9 @@ void saveViewerParameters(const char *filename, const char *servername) {
       fprintf(f, "%s=%d\n", ((BoolParameter*)param)->getName(), (int)*(BoolParameter*)param);
     } else {      
       fclose(f);
-      throw Exception(_("Failed to save \"%s\": %s"),
-                      param->getName(),
-                      _("Unknown parameter type"));
+      throw Exception(format(_("Failed to save \"%s\": %s"),
+                             param->getName(),
+                             _("Unknown parameter type")));
     }
   }
   fclose(f);
@@ -775,8 +777,8 @@ char* loadViewerParameters(const char *filename) {
 
     if (strlen(line) == (sizeof(line) - 1)) {
       fclose(f);
-      throw Exception(_("Failed to read line %d in file %s: %s"),
-                      lineNr, filepath, _("Line too long"));
+      throw Exception(format(_("Failed to read line %d in file %s: %s"),
+                             lineNr, filepath, _("Line too long")));
     }
 
     // Make sure that the first line of the file has the file identifier string
@@ -785,8 +787,8 @@ char* loadViewerParameters(const char *filename) {
         continue;
 
       fclose(f);
-      throw Exception(_("Configuration file %s is in an invalid format"),
-                      filepath);
+      throw Exception(format(_("Configuration file %s is in an invalid "
+                               "format"), filepath));
     }
     
     // Skip empty lines and comments