Server Capability Encodings

rfbEncodingSupportedEncodings - What encodings are supported?
rfbEncodingSupportedMessages  - What message types are supported?
rfbEncodingServerIdentity     - What is the servers version string?
ie: "x11vnc: 0.8.1 lastmod: 2006-04-25 (LibVNCServer 0.9pre)"

ChangeLog

@@ -1,3 +1,11 @@
+2006-05-04  Steven Carr <scarr@jsa-usa.com>
+	* rfbEncodingSupportedEncodings - What encodings are supported?
+	* rfbEncodingSupportedMessages - What message types are supported?
+	  This way a client can identify if a particular server supports a
+	  specific message types.
+	* rfbEncodingServerIdentity - What is the servers version string?
+	  ie: "x11vnc: 0.8.1 lastmod: 2006-04-25 (LibVNCServer 0.9pre)"
+
 2006-05-03  Steven Carr <scarr@jsa-usa.com>
 	* Server Side Scaling is now supported in libvncserver
 	  Both PalmVNC and UltraVNC SetScale messages are supported

libvncclient/rfbproto.c

@@ -532,25 +532,6 @@ SetFormatAndEncodings(rfbClient* client)
       encs[se->nEncodings++] = rfbClientSwap32IfLE(client->appData.qualityLevel +
 					  rfbEncodingQualityLevel0);
     }
-
-
-    if (client->appData.useRemoteCursor) {
-      if (se->nEncodings < MAX_ENCODINGS)
-	encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingXCursor);
-      if (se->nEncodings < MAX_ENCODINGS)
-	encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingRichCursor);
-      if (se->nEncodings < MAX_ENCODINGS)
-	encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingPointerPos);
-    }
-
-    /* Let's receive keyboard state encoding if available */
-    if (se->nEncodings < MAX_ENCODINGS) {
-        encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingKeyboardLedState);
-    }
-
-    if (se->nEncodings < MAX_ENCODINGS && requestLastRectEncoding) {
-      encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingLastRect);
-    }
   }
   else {
     if (SameMachine(client->sock)) {
@@ -570,6 +551,7 @@ SetFormatAndEncodings(rfbClient* client)
 #ifdef LIBVNCSERVER_HAVE_LIBZ
 #ifdef LIBVNCSERVER_HAVE_LIBJPEG
     encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingTight);
+    requestLastRectEncoding = TRUE;
 #endif
 #endif
     encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingHextile);
@@ -599,24 +581,42 @@ SetFormatAndEncodings(rfbClient* client)
       encs[se->nEncodings++] = rfbClientSwap32IfLE(client->appData.qualityLevel +
 					  rfbEncodingQualityLevel0);
     }
+  }
+
+
 
+  /* Remote Cursor Support (local to viewer) */
   if (client->appData.useRemoteCursor) {
+    if (se->nEncodings < MAX_ENCODINGS)
       encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingXCursor);
+    if (se->nEncodings < MAX_ENCODINGS)
       encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingRichCursor);
-      encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingPointerPos);
-    }
-
     if (se->nEncodings < MAX_ENCODINGS)
-      encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingLastRect);
+      encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingPointerPos);
   }
 
   /* Keyboard State Encodings */
   if (se->nEncodings < MAX_ENCODINGS)
     encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingKeyboardLedState);
 
+  /* New Frame Buffer Size */
   if (se->nEncodings < MAX_ENCODINGS && client->canHandleNewFBSize)
     encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingNewFBSize);
 
+  /* Last Rect */
+  if (se->nEncodings < MAX_ENCODINGS && requestLastRectEncoding)
+    encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingLastRect);
+
+  /* Server Capabilities */
+  if (se->nEncodings < MAX_ENCODINGS)
+    encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingSupportedMessages);
+  if (se->nEncodings < MAX_ENCODINGS)
+    encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingSupportedEncodings);
+  if (se->nEncodings < MAX_ENCODINGS)
+    encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingServerIdentity);
+
+
+  /* client extensions */
   for(e = rfbClientExtensions; e; e = e->next)
     if(e->encodings) {
       int* enc;
@@ -856,6 +856,65 @@ HandleRFBServerMessage(rfbClient* client)
 	continue;
       }
 
+      /* rect.r.w=byte count */
+      if (rect.encoding == rfbEncodingSupportedMessages) {
+          rfbSupportedMessages msgs;
+          int loop;
+          if (!ReadFromRFBServer(client, (char *)&msgs, sz_rfbSupportedMessages))
+              return FALSE;
+
+          /* msgs is two sets of bit flags of supported messages client2server[] and server2client[] */
+          /* currently ignored by this library */
+
+          rfbClientLog("client2server supported messages (bit flags)\n");
+          for (loop=0;loop<32;loop+=8)
+            rfbClientLog("%02X: %04x %04x %04x %04x - %04x %04x %04x %04x\n", loop,
+                msgs.client2server[loop],   msgs.client2server[loop+1],
+                msgs.client2server[loop+2], msgs.client2server[loop+3],
+                msgs.client2server[loop+4], msgs.client2server[loop+5],
+                msgs.client2server[loop+6], msgs.client2server[loop+7]);
+
+          rfbClientLog("server2client supported messages (bit flags)\n");
+          for (loop=0;loop<32;loop+=8)
+            rfbClientLog("%02X: %04x %04x %04x %04x - %04x %04x %04x %04x\n", loop,
+                msgs.server2client[loop],   msgs.server2client[loop+1],
+                msgs.server2client[loop+2], msgs.server2client[loop+3],
+                msgs.server2client[loop+4], msgs.server2client[loop+5],
+                msgs.server2client[loop+6], msgs.server2client[loop+7]);
+          continue;
+      }
+
+      /* rect.r.w=byte count, rect.r.h=# of encodings */
+      if (rect.encoding == rfbEncodingSupportedEncodings) {
+          char *buffer;
+          buffer = malloc(rect.r.w);
+          if (!ReadFromRFBServer(client, buffer, rect.r.w))
+          {
+              free(buffer);
+              return FALSE;
+          }
+
+          /* buffer now contains rect.r.h # of uint32_t encodings that the server supports */
+          /* currently ignored by this library */
+          free(buffer);
+          continue;
+      }
+
+      /* rect.r.w=byte count */
+      if (rect.encoding == rfbEncodingServerIdentity) {
+          char *buffer;
+          buffer = malloc(rect.r.w+1);
+          if (!ReadFromRFBServer(client, buffer, rect.r.w))
+          {
+              free(buffer);
+              return FALSE;
+          }
+          buffer[rect.r.w]=0; /* null terminate, just in case */
+          rfbClientLog("Connected to Server \"%s\"\n", buffer);
+          free(buffer);
+          continue;
+      }
+
       /* rfbEncodingUltraZip is a collection of subrects.   x = # of subrects, and h is always 0 */
       if (rect.encoding != rfbEncodingUltraZip)
       {

libvncserver/rfbserver.c

@@ -64,7 +64,7 @@
 #else
 #define DEBUGPROTO(x)
 #endif
-
+#include <stdarg.h>
 #include <scale.h>
 
 static void rfbProcessClientProtocolVersion(rfbClientPtr cl);
@@ -353,6 +353,9 @@ rfbNewTCPOrUDPClient(rfbScreenInfoPtr rfbScreen,
       cl->useRichCursorEncoding = FALSE;
       cl->enableLastRectEncoding = FALSE;
       cl->enableKeyboardLedState = FALSE;
+      cl->enableSupportedMessages = FALSE;
+      cl->enableSupportedEncodings = FALSE;
+      cl->enableServerIdentity = FALSE;
       cl->lastKeyboardLedState = -1;
       cl->cursorX = rfbScreen->cursorX;
       cl->cursorY = rfbScreen->cursorY;
@@ -782,6 +785,204 @@ rfbSendKeyboardLedState(rfbClientPtr cl)
 }
 
 
+#define rfbSetBit(buffer, position)  (buffer[(position & 255) / 8] |= (1 << (position % 8)))
+
+/*
+ * Send rfbEncodingSupportedMessages.
+ */
+
+rfbBool
+rfbSendSupportedMessages(rfbClientPtr cl)
+{
+    rfbFramebufferUpdateRectHeader rect;
+    rfbSupportedMessages msgs;
+
+    if (cl->ublen + sz_rfbFramebufferUpdateRectHeader
+                  + sz_rfbSupportedMessages > UPDATE_BUF_SIZE) {
+        if (!rfbSendUpdateBuf(cl))
+            return FALSE;
+    }
+
+    rect.encoding = Swap32IfLE(rfbEncodingSupportedMessages);
+    rect.r.x = 0;
+    rect.r.y = 0;
+    rect.r.w = Swap16IfLE(sz_rfbFramebufferUpdateRectHeader);
+    rect.r.h = 0;
+
+    memcpy(&cl->updateBuf[cl->ublen], (char *)&rect,
+        sz_rfbFramebufferUpdateRectHeader);
+    cl->ublen += sz_rfbFramebufferUpdateRectHeader;
+
+    memset((char *)&msgs, 0, sz_rfbSupportedMessages);
+    rfbSetBit(msgs.client2server, rfbSetPixelFormat);
+    rfbSetBit(msgs.client2server, rfbFixColourMapEntries);
+    rfbSetBit(msgs.client2server, rfbSetEncodings);
+    rfbSetBit(msgs.client2server, rfbFramebufferUpdateRequest);
+    rfbSetBit(msgs.client2server, rfbKeyEvent);
+    rfbSetBit(msgs.client2server, rfbPointerEvent);
+    rfbSetBit(msgs.client2server, rfbClientCutText);
+    rfbSetBit(msgs.client2server, rfbFileTransfer);
+    rfbSetBit(msgs.client2server, rfbSetScale);
+    //rfbSetBit(msgs.client2server, rfbSetServerInput);
+    //rfbSetBit(msgs.client2server, rfbSetSW);
+    //rfbSetBit(msgs.client2server, rfbTextChat);
+    //rfbSetBit(msgs.client2server, rfbKeyFrameRequest);
+    rfbSetBit(msgs.client2server, rfbPalmVNCSetScaleFactor);
+
+    rfbSetBit(msgs.server2client, rfbFramebufferUpdate);
+    rfbSetBit(msgs.server2client, rfbSetColourMapEntries);
+    rfbSetBit(msgs.server2client, rfbBell);
+    rfbSetBit(msgs.server2client, rfbServerCutText);
+    rfbSetBit(msgs.server2client, rfbResizeFrameBuffer);
+    //rfbSetBit(msgs.server2client, rfbKeyFrameUpdate);
+    rfbSetBit(msgs.server2client, rfbPalmVNCReSizeFrameBuffer);
+
+    memcpy(&cl->updateBuf[cl->ublen], (char *)&msgs, sz_rfbSupportedMessages);
+    cl->ublen += sz_rfbSupportedMessages;
+
+    if (!rfbSendUpdateBuf(cl))
+        return FALSE;
+
+    return TRUE;
+}
+
+
+
+static void rfbSendSupporteddEncodings_SendEncoding(rfbClientPtr cl, uint32_t enc)
+{
+    uint32_t nSwapped=0;
+    nSwapped = Swap32IfLE(enc);
+    memcpy(&cl->updateBuf[cl->ublen], (char *)&nSwapped, sizeof(nSwapped));
+    cl->ublen+=sizeof(nSwapped);
+}
+
+
+/*
+ * Send rfbEncodingSupportedEncodings.
+ */
+
+rfbBool
+rfbSendSupportedEncodings(rfbClientPtr cl)
+{
+    rfbFramebufferUpdateRectHeader rect;
+    uint16_t nEncodings=0;
+    
+    /* think rfbSetEncodingsMsg */
+
+    /* TODO: dynamic way of doing this */
+    nEncodings=16;
+#ifdef LIBVNCSERVER_HAVE_LIBZ
+    nEncodings += 2;
+#endif
+#ifdef LIBVNCSERVER_HAVE_LIBZ
+    nEncodings++;
+#endif
+
+    if (cl->ublen + sz_rfbFramebufferUpdateRectHeader
+                  + (nEncodings*sizeof(uint32_t)) > UPDATE_BUF_SIZE) {
+        if (!rfbSendUpdateBuf(cl))
+            return FALSE;
+    }
+
+    rect.encoding = Swap32IfLE(rfbEncodingSupportedEncodings);
+    rect.r.x = 0;
+    rect.r.y = 0;
+    rect.r.w = Swap16IfLE(nEncodings * sizeof(uint32_t));
+    rect.r.h = Swap16IfLE(nEncodings);
+
+    memcpy(&cl->updateBuf[cl->ublen], (char *)&rect,
+        sz_rfbFramebufferUpdateRectHeader);
+    cl->ublen += sz_rfbFramebufferUpdateRectHeader;
+
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingRaw);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingCopyRect);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingRRE);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingCoRRE);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingHextile);
+#ifdef LIBVNCSERVER_HAVE_LIBZ
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingZlib);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingTight);
+#endif
+#ifdef LIBVNCSERVER_HAVE_LIBZ
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingZRLE);
+#endif
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingUltra);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingUltraZip);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingXCursor);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingRichCursor);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingPointerPos);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingLastRect);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingNewFBSize);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingKeyboardLedState);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingSupportedMessages);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingSupportedEncodings);
+    rfbSendSupporteddEncodings_SendEncoding(cl, rfbEncodingServerIdentity);
+
+    if (!rfbSendUpdateBuf(cl))
+        return FALSE;
+
+    return TRUE;
+}
+
+
+void
+rfbSetServerVersionIdentity(rfbScreenInfoPtr screen, char *fmt, ...)
+{
+    char buffer[256];
+    va_list ap;
+    
+    va_start(ap, fmt);
+    vsnprintf(buffer, sizeof(buffer)-1, fmt, ap);
+    va_end(ap);
+    
+    if (screen->versionString!=NULL) free(screen->versionString);
+    screen->versionString = strdup(buffer);
+}
+
+/*
+ * Send rfbEncodingServerIdentity.
+ */
+
+rfbBool
+rfbSendServerIdentity(rfbClientPtr cl)
+{
+    rfbFramebufferUpdateRectHeader rect;
+    char buffer[512];
+
+    /* tack on our library version */
+    snprintf(buffer,sizeof(buffer)-1, "%s (%s)", 
+        (cl->screen->versionString==NULL ? "unknown" : cl->screen->versionString),
+        LIBVNCSERVER_PACKAGE_STRING);
+
+    if (cl->ublen + sz_rfbFramebufferUpdateRectHeader
+                  + (strlen(buffer)+1) > UPDATE_BUF_SIZE) {
+        if (!rfbSendUpdateBuf(cl))
+            return FALSE;
+    }
+
+    rect.encoding = Swap32IfLE(rfbEncodingServerIdentity);
+    rect.r.x = 0;
+    rect.r.y = 0;
+    rect.r.w = Swap16IfLE(strlen(buffer)+1);
+    rect.r.h = 0;
+
+    memcpy(&cl->updateBuf[cl->ublen], (char *)&rect,
+        sz_rfbFramebufferUpdateRectHeader);
+    cl->ublen += sz_rfbFramebufferUpdateRectHeader;
+
+    memcpy(&cl->updateBuf[cl->ublen], buffer, strlen(buffer)+1);
+    cl->ublen += strlen(buffer)+1;
+
+    if (!rfbSendUpdateBuf(cl))
+        return FALSE;
+
+    return TRUE;
+}
+
+
+
+
+
 /*
  * rfbProcessClientNormalMessage is called when the client has sent a normal
  * protocol message.
@@ -978,6 +1179,27 @@ rfbProcessClientNormalMessage(rfbClientPtr cl)
                   cl->enableKeyboardLedState = TRUE;
                 }
                 break;           
+            case rfbEncodingSupportedMessages:
+                if (!cl->enableSupportedMessages) {
+                  rfbLog("Enabling SupportedMessages protocol extension for client "
+                          "%s\n", cl->host);
+                  cl->enableSupportedMessages = TRUE;
+                }
+                break;           
+            case rfbEncodingSupportedEncodings:
+                if (!cl->enableSupportedEncodings) {
+                  rfbLog("Enabling SupportedEncodings protocol extension for client "
+                          "%s\n", cl->host);
+                  cl->enableSupportedEncodings = TRUE;
+                }
+                break;           
+            case rfbEncodingServerIdentity:
+                if (!cl->enableServerIdentity) {
+                  rfbLog("Enabling ServerIdentity protocol extension for client "
+                          "%s\n", cl->host);
+                  cl->enableServerIdentity = TRUE;
+                }
+                break;           
 #ifdef LIBVNCSERVER_HAVE_LIBZ
            case rfbEncodingZRLE:
                if (cl->preferredEncoding == -1) {
@@ -1268,6 +1490,9 @@ rfbSendFramebufferUpdate(rfbClientPtr cl,
     rfbBool sendCursorShape = FALSE;
     rfbBool sendCursorPos = FALSE;
     rfbBool sendKeyboardLedState = FALSE;
+    rfbBool sendSupportedMessages = FALSE;
+    rfbBool sendSupportedEncodings = FALSE;
+    rfbBool sendServerIdentity = FALSE;
     rfbBool result = TRUE;
     
 
@@ -1325,6 +1550,40 @@ rfbSendFramebufferUpdate(rfbClientPtr cl,
         }
     }
 
+    /*
+     * Do we plan to send a rfbEncodingSupportedMessages?
+     */
+    if (cl->enableSupportedMessages)
+    {
+        sendSupportedMessages = TRUE;
+        /* We only send this message ONCE <per setEncodings message received>
+         * (We disable it here)
+         */
+        cl->enableSupportedMessages = FALSE;
+    }
+    /*
+     * Do we plan to send a rfbEncodingSupportedEncodings?
+     */
+    if (cl->enableSupportedEncodings)
+    {
+        sendSupportedEncodings = TRUE;
+        /* We only send this message ONCE <per setEncodings message received>
+         * (We disable it here)
+         */
+        cl->enableSupportedEncodings = FALSE;
+    }
+    /*
+     * Do we plan to send a rfbEncodingServerIdentity?
+     */
+    if (cl->enableServerIdentity)
+    {
+        sendServerIdentity = TRUE;
+        /* We only send this message ONCE <per setEncodings message received>
+         * (We disable it here)
+         */
+        cl->enableServerIdentity = FALSE;
+    }
+
     LOCK(cl->updateMutex);
 
     /*
@@ -1368,7 +1627,8 @@ rfbSendFramebufferUpdate(rfbClientPtr cl,
        sraRgnEmpty(updateRegion) &&
        (cl->enableCursorShapeUpdates ||
 	(cl->cursorX == cl->screen->cursorX && cl->cursorY == cl->screen->cursorY)) &&
-       !sendCursorShape && !sendCursorPos && !sendKeyboardLedState) {
+       !sendCursorShape && !sendCursorPos && !sendKeyboardLedState &&
+       !sendSupportedMessages && !sendSupportedEncodings && !sendServerIdentity) {
       sraRgnDestroy(updateRegion);
       UNLOCK(cl->updateMutex);
       return TRUE;
@@ -1529,7 +1789,8 @@ rfbSendFramebufferUpdate(rfbClientPtr cl,
 	}
 	fu->nRects = Swap16IfLE((uint16_t)(sraRgnCountRects(updateCopyRegion) +
 					   nUpdateRegionRects +
-					   !!sendCursorShape + !!sendCursorPos + !!sendKeyboardLedState));
+					   !!sendCursorShape + !!sendCursorPos + !!sendKeyboardLedState +
+					   !!sendSupportedMessages + !!sendSupportedEncodings + !!sendServerIdentity));
     } else {
 	fu->nRects = 0xFFFF;
     }
@@ -1552,6 +1813,19 @@ rfbSendFramebufferUpdate(rfbClientPtr cl,
            goto updateFailed;
    }
 
+   if (sendSupportedMessages) {
+       if (!rfbSendSupportedMessages(cl))
+           goto updateFailed;
+   }
+   if (sendSupportedEncodings) {
+       if (!rfbSendSupportedEncodings(cl))
+           goto updateFailed;
+   }
+   if (sendServerIdentity) {
+       if (!rfbSendServerIdentity(cl))
+           goto updateFailed;
+   }
+   
     if (!sraRgnEmpty(updateCopyRegion)) {
 	if (!rfbSendCopyRegion(cl,updateCopyRegion,dx,dy))
 	        goto updateFailed;

rfb/rfb.h

@@ -323,6 +323,9 @@ typedef struct _rfbScreenInfo
 
     /* handle as many input events as possible (default off) */
     rfbBool handleEventsEagerly;
+
+    /* rfbEncodingServerIdentity */
+    char *versionString;
 } rfbScreenInfo, *rfbScreenInfoPtr;
 
 
@@ -501,6 +504,9 @@ typedef struct _rfbClientRec {
 
 
     int     lastKeyboardLedState;     /* keep track of last value so we can send *change* events */
+    rfbBool enableSupportedMessages;  /* client supports SupportedMessages encoding */
+    rfbBool enableSupportedEncodings; /* client supports SupportedEncodings encoding */
+    rfbBool enableServerIdentity;     /* client supports ServerIdentity encoding */
     rfbBool enableKeyboardLedState;   /* client supports KeyboardState encoding */
     rfbBool enableLastRectEncoding;   /* client supports LastRect encoding */
     rfbBool enableCursorShapeUpdates; /* client supports cursor shape updates */
@@ -852,6 +858,7 @@ extern void rfbNewFramebuffer(rfbScreenInfoPtr rfbScreen,char *framebuffer,
  int bytesPerPixel);
 
 extern void rfbScreenCleanup(rfbScreenInfoPtr screenInfo);
+extern void rfbSetServerVersionIdentity(rfbScreenInfoPtr screen, char *fmt, ...);
 
 /* functions to accept/refuse a client that has been put on hold
    by a NewClientHookPtr function. Must not be called in other

rfb/rfbproto.h

@@ -401,8 +401,8 @@ typedef struct {
 #define rfbEncodingZlib 6
 #define rfbEncodingTight 7
 #define rfbEncodingZlibHex 8
-#define rfbEncodingUltra 9
 #endif
+#define rfbEncodingUltra 9
 #ifdef LIBVNCSERVER_HAVE_LIBZ
 #define rfbEncodingZRLE 16
 #endif
@@ -449,6 +449,9 @@ typedef struct {
 #define rfbEncodingLastRect           0xFFFFFF20
 #define rfbEncodingNewFBSize          0xFFFFFF21
 #define rfbEncodingKeyboardLedState   0xFFFFFF22
+#define rfbEncodingSupportedMessages  0xFFFFFF23
+#define rfbEncodingSupportedEncodings 0xFFFFFF24
+#define rfbEncodingServerIdentity     0xFFFFFF25
 
 #define rfbEncodingQualityLevel0   0xFFFFFFE0
 #define rfbEncodingQualityLevel1   0xFFFFFFE1
@@ -514,6 +517,34 @@ typedef struct {
 
 #define sz_rfbFramebufferUpdateRectHeader (sz_rfbRectangle + 4)
 
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * Supported Messages Encoding.  This encoding does not contain any pixel data.
+ * Instead, it contains 2 sets of bitflags.  These bitflags indicate what messages
+ * are supported by the server.
+ * rect->w contains byte count
+ */
+
+typedef struct {
+  uint8_t client2server[32]; /* maximum of 256 message types (256/8)=32 */
+  uint8_t server2client[32]; /* maximum of 256 message types (256/8)=32 */
+} rfbSupportedMessages;
+
+#define sz_rfbSupportedMessages 64
+
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * Supported Encodings Encoding.  This encoding does not contain any pixel data.
+ * Instead, it contains a list of (uint32_t) Encodings supported by this server.
+ * rect->w contains byte count
+ * rect->h contains encoding count
+ */
+
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * Server Identity Encoding.  This encoding does not contain any pixel data.
+ * Instead, it contains a text string containing information about the server.
+ * ie: "x11vnc: 0.8.1 lastmod: 2006-04-25 (libvncserver 0.9pre)\0"
+ * rect->w contains byte count
+ */
+
 
 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  * Raw Encoding.  Pixels are sent in top-to-bottom scanline order,
@@ -1244,7 +1275,7 @@ typedef struct _rfbSetScaleMsg {
  * client buffer.
  */
 typedef struct {
-    uint8_t type;			/* always rfbSetScaleFactor */
+    uint8_t type;			/* always rfbPalmVNCSetScaleFactor */
 
     uint8_t scale;		/* Scale factor (positive non-zero integer) */
     uint16_t pad2;

x11vnc/screen.c

@@ -1966,6 +1966,8 @@ void initialize_screen(int *argc, char **argv, XImage *fb) {
 		screen->deferUpdateTime = defer_update;
 	}
 
+	rfbSetServerVersionIdentity(screen, "x11vnc: %s", lastmod);
+
 	rfbInitServer(screen);
 
 	if (use_openssl) {