TDE
/
libtdevnc
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/libtdevnc
0
0
Fork 0
Code Issues Releases Wiki Activity

The great UltraVNC Compatibility Commit

Browse Source
pull/1/head
steven_carr 18 years ago
parent 347c4a9847
commit ccdbe8f325
25 changed files with 1935 additions and 301 deletions
Show Stats Download Patch File Download Diff File

20
ChangeLog
Unescape View File

@ -1,3 +1,23 @@
2006-05-15 Steven Carr <scarr@jsa-usa.com>
* The great UltraVNC Compatibility Commit!
libvncserver now supports the following messages:
SetSingleWindow - Select a single window to be the source of the
framebuffer.
ServerInput - Disable and blank the servers display
TextChat - TextChat between the remote/local user
(Bandwidth friendly VS the Notepad approach)
FileTransfer - Emulates a Windows Filesystem to the viewer
(Currently does not support Delta Transfers)
(Currently does not support Sending Directories)
UltraZip - Improved UltraZip support
* Improved Statistics SubSystem, now supports all encodings
* RFB 3.8 support! Error Messages are a 'Good Thing' (tm)
* Default to identify as RFB 3.6 to emulate UltraVNC server
(Server now has the ability to set the RFB version reported)
(permits the viewer to identify the server has FileTransfer ability)
* Client Encoding AutoSelection Supported (UltraViewer is speed aware)
* libvncclient has improved server detection/capabilities logic!
2006-05-13 Karl Runge <runge@karlrunge.com> 2006-05-13 Karl Runge <runge@karlrunge.com>
* minilzo.c,minilzo.h,lzoconf.h: switch to non-CRLF versions. * minilzo.c,minilzo.h,lzoconf.h: switch to non-CRLF versions.
* libvncclient/Makefile.am: add minilzo.c, minilzo.h, lzoconf.h * libvncclient/Makefile.am: add minilzo.c, minilzo.h, lzoconf.h

22
client_examples/SDLvncviewer.c
Unescape View File

@ -150,6 +150,26 @@ static void kbd_leds(rfbClient* cl, int value, int pad) {
fflush(stderr); fflush(stderr);
} }
/* trivial support for textchat */
static void text_chat(rfbClient* cl, int value, char *text) {
switch(value) {
case rfbTextChatOpen:
fprintf(stderr,"TextChat: We should open a textchat window!\n");
TextChatOpen(cl);
break;
case rfbTextChatClose:
fprintf(stderr,"TextChat: We should close our window!\n");
break;
case rfbTextChatFinished:
fprintf(stderr,"TextChat: We should close our window!\n");
break;
default:
fprintf(stderr,"TextChat: Received \"%s\"\n", text);
break;
}
fflush(stderr);
}
#ifdef __MINGW32__ #ifdef __MINGW32__
#define LOG_TO_FILE #define LOG_TO_FILE
#endif #endif
@ -212,7 +232,7 @@ int main(int argc,char** argv) {
cl->canHandleNewFBSize = TRUE; cl->canHandleNewFBSize = TRUE;
cl->GotFrameBufferUpdate=update; cl->GotFrameBufferUpdate=update;
cl->HandleKeyboardLedState=kbd_leds; cl->HandleKeyboardLedState=kbd_leds;
cl->HandleTextChat=text_chat;
if(!rfbInitClient(cl,&argc,argv)) if(!rfbInitClient(cl,&argc,argv))
return 1; return 1;

366
libvncclient/rfbproto.c
Unescape View File

@ -223,6 +223,99 @@ static rfbBool HandleZRLE24Down(rfbClient* client, int rx, int ry, int rw, int r
static rfbBool HandleZRLE32(rfbClient* client, int rx, int ry, int rw, int rh); static rfbBool HandleZRLE32(rfbClient* client, int rx, int ry, int rw, int rh);
#endif #endif
/*
* Server Capability Functions
*/
rfbBool
SupportsClient2Server(rfbClient* client, int messageType)
{
return (client->supportedMessages.client2server[((messageType & 0xFF)/8)] & (1<<(messageType % 8)) ? TRUE : FALSE);
}
rfbBool
SupportsServer2Client(rfbClient* client, int messageType)
{
return (client->supportedMessages.server2client[((messageType & 0xFF)/8)] & (1<<(messageType % 8)) ? TRUE : FALSE);
}
void
SetClient2Server(rfbClient* client, int messageType)
{
client->supportedMessages.client2server[((messageType & 0xFF)/8)] |= (1<<(messageType % 8));
}
void
SetServer2Client(rfbClient* client, int messageType)
{
client->supportedMessages.server2client[((messageType & 0xFF)/8)] |= (1<<(messageType % 8));
}
void
ClearClient2Server(rfbClient* client, int messageType)
{
client->supportedMessages.client2server[((messageType & 0xFF)/8)] &= (!(1<<(messageType % 8)));
}
void
ClearServer2Client(rfbClient* client, int messageType)
{
client->supportedMessages.server2client[((messageType & 0xFF)/8)] &= (!(1<<(messageType % 8)));
}
void
DefaultSupportedMessages(rfbClient* client)
{
memset((char *)&client->supportedMessages,0,sizeof(client->supportedMessages));
/* Default client supported messages (universal RFB 3.3 protocol) */
SetClient2Server(client, rfbSetPixelFormat);
/* SetClient2Server(client, rfbFixColourMapEntries); Not currently supported */
SetClient2Server(client, rfbSetEncodings);
SetClient2Server(client, rfbFramebufferUpdateRequest);
SetClient2Server(client, rfbKeyEvent);
SetClient2Server(client, rfbPointerEvent);
SetClient2Server(client, rfbClientCutText);
/* technically, we only care what we can *send* to the server
* but, we set Server2Client Just in case it ever becomes useful
*/
SetServer2Client(client, rfbFramebufferUpdate);
SetServer2Client(client, rfbSetColourMapEntries);
SetServer2Client(client, rfbBell);
SetServer2Client(client, rfbServerCutText);
}
void
DefaultSupportedMessagesUltraVNC(rfbClient* client)
{
DefaultSupportedMessages(client);
SetClient2Server(client, rfbFileTransfer);
SetClient2Server(client, rfbSetScale);
SetClient2Server(client, rfbSetServerInput);
SetClient2Server(client, rfbSetSW);
SetClient2Server(client, rfbTextChat);
SetClient2Server(client, rfbPalmVNCSetScaleFactor);
/* technically, we only care what we can *send* to the server */
SetServer2Client(client, rfbResizeFrameBuffer);
SetServer2Client(client, rfbPalmVNCReSizeFrameBuffer);
SetServer2Client(client, rfbFileTransfer);
SetServer2Client(client, rfbTextChat);
}
void
DefaultSupportedMessagesTightVNC(rfbClient* client)
{
DefaultSupportedMessages(client);
SetClient2Server(client, rfbFileTransfer);
SetClient2Server(client, rfbSetServerInput);
SetClient2Server(client, rfbSetSW);
/* SetClient2Server(client, rfbTextChat); */
/* technically, we only care what we can *send* to the server */
SetServer2Client(client, rfbFileTransfer);
SetServer2Client(client, rfbTextChat);
}
/* /*
* ConnectToRFBServer. * ConnectToRFBServer.
*/ */
@ -310,26 +403,87 @@ InitialiseRFBConnection(rfbClient* client)
return FALSE; return FALSE;
} }
#if rfbProtocolMinorVersion == 7
/* work around LibVNCClient not yet speaking RFB 3.7 */ DefaultSupportedMessages(client);
#undef rfbProtocolMinorVersion client->major = major;
#define rfbProtocolMinorVersion 3 client->minor = minor;
#endif
/* fall back to viewer supported version */
if ((major==rfbProtocolMajorVersion) && (minor>rfbProtocolMinorVersion))
client->minor = rfbProtocolMinorVersion;
/* UltraVNC uses minor codes 4 and 6 for the server */
if (major==3 && (minor==4 || minor==6)) {
rfbClientLog("UltraVNC server detected, enabling UltraVNC specific messages\n",pv);
DefaultSupportedMessagesUltraVNC(client);
}
/* TightVNC uses minor codes 5 for the server */
if (major==3 && minor==5) {
rfbClientLog("TightVNC server detected, enabling TightVNC specific messages\n",pv);
DefaultSupportedMessagesTightVNC(client);
}
/* we do not support > RFB3.8 */
if (major==3 && minor>8)
client->minor=8;
rfbClientLog("VNC server supports protocol version %d.%d (viewer %d.%d)\n", rfbClientLog("VNC server supports protocol version %d.%d (viewer %d.%d)\n",
major, minor, rfbProtocolMajorVersion, rfbProtocolMinorVersion); major, minor, rfbProtocolMajorVersion, rfbProtocolMinorVersion);
major = rfbProtocolMajorVersion; sprintf(pv,rfbProtocolVersionFormat,client->major,client->minor);
minor = rfbProtocolMinorVersion;
sprintf(pv,rfbProtocolVersionFormat,major,minor);
if (!WriteToRFBServer(client, pv, sz_rfbProtocolVersionMsg)) return FALSE; if (!WriteToRFBServer(client, pv, sz_rfbProtocolVersionMsg)) return FALSE;
if (!ReadFromRFBServer(client, (char *)&authScheme, 4)) return FALSE;
authScheme = rfbClientSwap32IfLE(authScheme); /* 3.7 and onwards sends a # of security types first */
if (client->major==3 && client->minor > 6)
{
uint8_t count=0;
uint8_t loop=0;
uint8_t flag=0;
uint8_t tAuth=0;
if (!ReadFromRFBServer(client, (char *)&count, 1)) return FALSE;
if (count==0)
{
rfbClientLog("List of security types is ZERO, expecting an error to follow\n");
/* we have an error following */
if (!ReadFromRFBServer(client, (char *)&reasonLen, 4)) return FALSE;
reasonLen = rfbClientSwap32IfLE(reasonLen);
reason = malloc(reasonLen);
if (!ReadFromRFBServer(client, reason, reasonLen)) { free(reason); return FALSE; }
rfbClientLog("VNC connection failed: %.*s\n",(int)reasonLen, reason);
free(reason);
return FALSE;
}
rfbClientLog("We have %d security types to read\n", count);
/* now, we have a list of available security types to read ( uint8_t[] ) */
for (loop=0;loop<count;loop++)
{
if (!ReadFromRFBServer(client, (char *)&tAuth, 1)) return FALSE;
rfbClientLog("%d) Received security type %d\n", loop, tAuth);
if ((flag==0) && ((tAuth==rfbVncAuth) || (tAuth==rfbNoAuth)))
{
flag++;
authScheme=tAuth;
rfbClientLog("Selecting security type %d (%d/%d in the list)\n", authScheme, loop, count);
/* send back a single byte indicating which security type to use */
if (!WriteToRFBServer(client, (char *)&tAuth, 1)) return FALSE;
}
}
}
else
{
if (!ReadFromRFBServer(client, (char *)&authScheme, 4)) return FALSE;
authScheme = rfbClientSwap32IfLE(authScheme);
}
rfbClientLog("Selected Security Scheme %d\n", authScheme);
switch (authScheme) { switch (authScheme) {
case rfbConnFailed: case rfbConnFailed:
@ -338,9 +492,10 @@ InitialiseRFBConnection(rfbClient* client)
reason = malloc(reasonLen); reason = malloc(reasonLen);
if (!ReadFromRFBServer(client, reason, reasonLen)) return FALSE; if (!ReadFromRFBServer(client, reason, reasonLen)) { free(reason); return FALSE; }
rfbClientLog("VNC connection failed: %.*s\n",(int)reasonLen, reason); rfbClientLog("VNC connection failed: %.*s\n",(int)reasonLen, reason);
free(reason);
return FALSE; return FALSE;
case rfbNoAuth: case rfbNoAuth:
@ -382,6 +537,17 @@ InitialiseRFBConnection(rfbClient* client)
rfbClientLog("VNC authentication succeeded\n"); rfbClientLog("VNC authentication succeeded\n");
break; break;
case rfbVncAuthFailed: case rfbVncAuthFailed:
if (client->major==3 && client->minor>7)
{
/* we have an error following */
if (!ReadFromRFBServer(client, (char *)&reasonLen, 4)) return FALSE;
reasonLen = rfbClientSwap32IfLE(reasonLen);
reason = malloc(reasonLen);
if (!ReadFromRFBServer(client, reason, reasonLen)) { free(reason); return FALSE; }
rfbClientLog("VNC connection failed: %.*s\n",(int)reasonLen, reason);
free(reason);
return FALSE;
}
rfbClientLog("VNC authentication failed\n"); rfbClientLog("VNC authentication failed\n");
return FALSE; return FALSE;
case rfbVncAuthTooMany: case rfbVncAuthTooMany:
@ -427,7 +593,7 @@ InitialiseRFBConnection(rfbClient* client)
rfbClientLog("Desktop name \"%s\"\n",client->desktopName); rfbClientLog("Desktop name \"%s\"\n",client->desktopName);
rfbClientLog("Connected to VNC server, using protocol version %d.%d\n", rfbClientLog("Connected to VNC server, using protocol version %d.%d\n",
rfbProtocolMajorVersion, rfbProtocolMinorVersion); client->major, client->minor);
rfbClientLog("VNC server default format:\n"); rfbClientLog("VNC server default format:\n");
PrintPixelFormat(&client->si.format); PrintPixelFormat(&client->si.format);
@ -445,6 +611,7 @@ SetFormatAndEncodings(rfbClient* client)
{ {
rfbSetPixelFormatMsg spf; rfbSetPixelFormatMsg spf;
char buf[sz_rfbSetEncodingsMsg + MAX_ENCODINGS * 4]; char buf[sz_rfbSetEncodingsMsg + MAX_ENCODINGS * 4];
rfbSetEncodingsMsg *se = (rfbSetEncodingsMsg *)buf; rfbSetEncodingsMsg *se = (rfbSetEncodingsMsg *)buf;
uint32_t *encs = (uint32_t *)(&buf[sz_rfbSetEncodingsMsg]); uint32_t *encs = (uint32_t *)(&buf[sz_rfbSetEncodingsMsg]);
int len = 0; int len = 0;
@ -453,6 +620,8 @@ SetFormatAndEncodings(rfbClient* client)
rfbBool requestLastRectEncoding = FALSE; rfbBool requestLastRectEncoding = FALSE;
rfbClientProtocolExtension* e; rfbClientProtocolExtension* e;
if (!SupportsClient2Server(client, rfbSetPixelFormat)) return TRUE;
spf.type = rfbSetPixelFormat; spf.type = rfbSetPixelFormat;
spf.format = client->format; spf.format = client->format;
spf.format.redMax = rfbClientSwap16IfLE(spf.format.redMax); spf.format.redMax = rfbClientSwap16IfLE(spf.format.redMax);
@ -462,6 +631,9 @@ SetFormatAndEncodings(rfbClient* client)
if (!WriteToRFBServer(client, (char *)&spf, sz_rfbSetPixelFormatMsg)) if (!WriteToRFBServer(client, (char *)&spf, sz_rfbSetPixelFormatMsg))
return FALSE; return FALSE;
if (!SupportsClient2Server(client, rfbSetEncodings)) return TRUE;
se->type = rfbSetEncodings; se->type = rfbSetEncodings;
se->nEncodings = 0; se->nEncodings = 0;
@ -641,7 +813,7 @@ SetFormatAndEncodings(rfbClient* client)
rfbBool rfbBool
SendIncrementalFramebufferUpdateRequest(rfbClient* client) SendIncrementalFramebufferUpdateRequest(rfbClient* client)
{ {
return SendFramebufferUpdateRequest(client, 0, 0, client->width, return SendFramebufferUpdateRequest(client, 0, 0, client->width,
client->height, TRUE); client->height, TRUE);
} }
@ -655,6 +827,8 @@ SendFramebufferUpdateRequest(rfbClient* client, int x, int y, int w, int h, rfbB
{ {
rfbFramebufferUpdateRequestMsg fur; rfbFramebufferUpdateRequestMsg fur;
if (!SupportsClient2Server(client, rfbFramebufferUpdateRequest)) return TRUE;
fur.type = rfbFramebufferUpdateRequest; fur.type = rfbFramebufferUpdateRequest;
fur.incremental = incremental ? 1 : 0; fur.incremental = incremental ? 1 : 0;
fur.x = rfbClientSwap16IfLE(x); fur.x = rfbClientSwap16IfLE(x);
@ -677,19 +851,105 @@ SendScaleSetting(rfbClient* client,int scaleSetting)
{ {
rfbSetScaleMsg ssm; rfbSetScaleMsg ssm;
if (client->appData.palmVNC)
ssm.type = rfbPalmVNCSetScaleFactor;
else
ssm.type = rfbSetScale;
ssm.scale = scaleSetting; ssm.scale = scaleSetting;
ssm.pad = 0; ssm.pad = 0;
if (!WriteToRFBServer(client, (char *)&ssm, sz_rfbSetScaleMsg)) /* favor UltraVNC SetScale if both are supported */
return FALSE; if (SupportsClient2Server(client, rfbSetScale)) {
ssm.type = rfbSetScale;
if (!WriteToRFBServer(client, (char *)&ssm, sz_rfbSetScaleMsg))
return FALSE;
}
if (SupportsClient2Server(client, rfbPalmVNCSetScaleFactor)) {
ssm.type = rfbPalmVNCSetScaleFactor;
if (!WriteToRFBServer(client, (char *)&ssm, sz_rfbSetScaleMsg))
return FALSE;
}
return TRUE; return TRUE;
} }
/*
* TextChatFunctions (UltraVNC)
* Extremely bandwidth friendly method of communicating with a user
* (Think HelpDesk type applications)
*/
rfbBool TextChatSend(rfbClient* client, char *text)
{
rfbTextChatMsg chat;
int count = strlen(text);
if (!SupportsClient2Server(client, rfbTextChat)) return TRUE;
chat.type = rfbTextChat;
chat.pad1 = 0;
chat.pad2 = 0;
chat.length = (uint32_t)count;
chat.length = rfbClientSwap32IfLE(chat.length);
if (!WriteToRFBServer(client, (char *)&chat, sz_rfbTextChatMsg))
return FALSE;
if (count>0) {
if (!WriteToRFBServer(client, text, count))
return FALSE;
}
return TRUE;
}
rfbBool TextChatOpen(rfbClient* client)
{
rfbTextChatMsg chat;
if (!SupportsClient2Server(client, rfbTextChat)) return TRUE;
chat.type = rfbTextChat;
chat.pad1 = 0;
chat.pad2 = 0;
chat.length = rfbClientSwap32IfLE(rfbTextChatOpen);
return (WriteToRFBServer(client, (char *)&chat, sz_rfbTextChatMsg) ? TRUE : FALSE);
}
rfbBool TextChatClose(rfbClient* client)
{
rfbTextChatMsg chat;
if (!SupportsClient2Server(client, rfbTextChat)) return TRUE;
chat.type = rfbTextChat;
chat.pad1 = 0;
chat.pad2 = 0;
chat.length = rfbClientSwap32IfLE(rfbTextChatClose);
return (WriteToRFBServer(client, (char *)&chat, sz_rfbTextChatMsg) ? TRUE : FALSE);
}
rfbBool TextChatFinish(rfbClient* client)
{
rfbTextChatMsg chat;
if (!SupportsClient2Server(client, rfbTextChat)) return TRUE;
chat.type = rfbTextChat;
chat.pad1 = 0;
chat.pad2 = 0;
chat.length = rfbClientSwap32IfLE(rfbTextChatFinished);
return (WriteToRFBServer(client, (char *)&chat, sz_rfbTextChatMsg) ? TRUE : FALSE);
}
/*
* UltraVNC Server Input Disable
* Apparently, the remote client can *prevent* the local user from interacting with the display
* I would think this is extremely helpful when used in a HelpDesk situation
*/
rfbBool PermitServerInput(rfbClient* client, int enabled)
{
rfbSetServerInputMsg msg;
if (!SupportsClient2Server(client, rfbSetServerInput)) return TRUE;
/* enabled==1, then server input from local keyboard is disabled */
msg.type = rfbSetServerInput;
msg.status = (enabled ? 1 : 0);
msg.pad = 0;
return (WriteToRFBServer(client, (char *)&msg, sz_rfbSetServerInputMsg) ? TRUE : FALSE);
}
/* /*
* SendPointerEvent. * SendPointerEvent.
*/ */
@ -699,6 +959,8 @@ SendPointerEvent(rfbClient* client,int x, int y, int buttonMask)
{ {
rfbPointerEventMsg pe; rfbPointerEventMsg pe;
if (!SupportsClient2Server(client, rfbPointerEvent)) return TRUE;
pe.type = rfbPointerEvent; pe.type = rfbPointerEvent;
pe.buttonMask = buttonMask; pe.buttonMask = buttonMask;
if (x < 0) x = 0; if (x < 0) x = 0;
@ -719,6 +981,8 @@ SendKeyEvent(rfbClient* client, uint32_t key, rfbBool down)
{ {
rfbKeyEventMsg ke; rfbKeyEventMsg ke;
if (!SupportsClient2Server(client, rfbKeyEvent)) return TRUE;
ke.type = rfbKeyEvent; ke.type = rfbKeyEvent;
ke.down = down ? 1 : 0; ke.down = down ? 1 : 0;
ke.key = rfbClientSwap32IfLE(key); ke.key = rfbClientSwap32IfLE(key);
@ -739,6 +1003,8 @@ SendClientCutText(rfbClient* client, char *str, int len)
free(client->serverCutText); free(client->serverCutText);
client->serverCutText = NULL; client->serverCutText = NULL;
if (!SupportsClient2Server(client, rfbClientCutText)) return TRUE;
cct.type = rfbClientCutText; cct.type = rfbClientCutText;
cct.length = rfbClientSwap32IfLE(len); cct.length = rfbClientSwap32IfLE(len);
return (WriteToRFBServer(client, (char *)&cct, sz_rfbClientCutTextMsg) && return (WriteToRFBServer(client, (char *)&cct, sz_rfbClientCutTextMsg) &&
@ -858,9 +1124,8 @@ HandleRFBServerMessage(rfbClient* client)
/* rect.r.w=byte count */ /* rect.r.w=byte count */
if (rect.encoding == rfbEncodingSupportedMessages) { if (rect.encoding == rfbEncodingSupportedMessages) {
rfbSupportedMessages msgs;
int loop; int loop;
if (!ReadFromRFBServer(client, (char *)&msgs, sz_rfbSupportedMessages)) if (!ReadFromRFBServer(client, (char *)&client->supportedMessages, sz_rfbSupportedMessages))
return FALSE; return FALSE;
/* msgs is two sets of bit flags of supported messages client2server[] and server2client[] */ /* msgs is two sets of bit flags of supported messages client2server[] and server2client[] */
@ -869,18 +1134,18 @@ HandleRFBServerMessage(rfbClient* client)
rfbClientLog("client2server supported messages (bit flags)\n"); rfbClientLog("client2server supported messages (bit flags)\n");
for (loop=0;loop<32;loop+=8) for (loop=0;loop<32;loop+=8)
rfbClientLog("%02X: %04x %04x %04x %04x - %04x %04x %04x %04x\n", loop, rfbClientLog("%02X: %04x %04x %04x %04x - %04x %04x %04x %04x\n", loop,
msgs.client2server[loop], msgs.client2server[loop+1], client->supportedMessages.client2server[loop], client->supportedMessages.client2server[loop+1],
msgs.client2server[loop+2], msgs.client2server[loop+3], client->supportedMessages.client2server[loop+2], client->supportedMessages.client2server[loop+3],
msgs.client2server[loop+4], msgs.client2server[loop+5], client->supportedMessages.client2server[loop+4], client->supportedMessages.client2server[loop+5],
msgs.client2server[loop+6], msgs.client2server[loop+7]); client->supportedMessages.client2server[loop+6], client->supportedMessages.client2server[loop+7]);
rfbClientLog("server2client supported messages (bit flags)\n"); rfbClientLog("server2client supported messages (bit flags)\n");
for (loop=0;loop<32;loop+=8) for (loop=0;loop<32;loop+=8)
rfbClientLog("%02X: %04x %04x %04x %04x - %04x %04x %04x %04x\n", loop, rfbClientLog("%02X: %04x %04x %04x %04x - %04x %04x %04x %04x\n", loop,
msgs.server2client[loop], msgs.server2client[loop+1], client->supportedMessages.server2client[loop], client->supportedMessages.server2client[loop+1],
msgs.server2client[loop+2], msgs.server2client[loop+3], client->supportedMessages.server2client[loop+2], client->supportedMessages.server2client[loop+3],
msgs.server2client[loop+4], msgs.server2client[loop+5], client->supportedMessages.server2client[loop+4], client->supportedMessages.server2client[loop+5],
msgs.server2client[loop+6], msgs.server2client[loop+7]); client->supportedMessages.server2client[loop+6], client->supportedMessages.server2client[loop+7]);
continue; continue;
} }
@ -1217,6 +1482,47 @@ HandleRFBServerMessage(rfbClient* client)
break; break;
} }
case rfbTextChat:
{
char *buffer=NULL;
if (!ReadFromRFBServer(client, ((char *)&msg) + 1,
sz_rfbTextChatMsg- 1))
return FALSE;
msg.tc.length = rfbClientSwap32IfLE(msg.sct.length);
switch(msg.tc.length) {
case rfbTextChatOpen:
rfbClientLog("Received TextChat Open\n");
if (client->HandleTextChat!=NULL)
client->HandleTextChat(client, (int)rfbTextChatOpen, NULL);
break;
case rfbTextChatClose:
rfbClientLog("Received TextChat Close\n");
if (client->HandleTextChat!=NULL)
client->HandleTextChat(client, (int)rfbTextChatClose, NULL);
break;
case rfbTextChatFinished:
rfbClientLog("Received TextChat Finished\n");
if (client->HandleTextChat!=NULL)
client->HandleTextChat(client, (int)rfbTextChatFinished, NULL);
break;
default:
buffer=malloc(msg.tc.length+1);
if (!ReadFromRFBServer(client, buffer, msg.tc.length))
{
free(buffer);
return FALSE;
}
/* Null Terminate <just in case> */
buffer[msg.tc.length]=0;
rfbClientLog("Received TextChat \"%s\"\n", buffer);
if (client->HandleTextChat!=NULL)
client->HandleTextChat(client, (int)msg.tc.length, buffer);
free(buffer);
break;
}
break;
}
case rfbResizeFrameBuffer: case rfbResizeFrameBuffer:
{ {
if (!ReadFromRFBServer(client, ((char *)&msg) + 1, if (!ReadFromRFBServer(client, ((char *)&msg) + 1,

4
libvncclient/ultra.c
Unescape View File

@ -18,8 +18,6 @@
* USA. * USA.
*/ */
#ifdef LIBVNCSERVER_HAVE_LIBZ
/* /*
* ultrazip.c - handle ultrazip encoding. * ultrazip.c - handle ultrazip encoding.
* *
@ -210,5 +208,3 @@ HandleUltraZipBPP (rfbClient* client, int rx, int ry, int rw, int rh)
} }
#undef CARDBPP #undef CARDBPP
#endif

2
libvncclient/zrle.c
Unescape View File

@ -377,7 +377,7 @@ static int HandleZRLETile(rfbClient* client,
#undef HandleZRLETile #undef HandleZRLETile
#undef UncompressCPixel #undef UncompressCPixel
#undef REALBPP #undef REALBPP
#undef UNCOMP
#endif #endif
#undef UNCOMP

7
libvncserver/auth.c
Unescape View File

@ -317,7 +317,12 @@ rfbAuthProcessClientMessage(rfbClientPtr cl)
if (rfbWriteExact(cl, (char *)&authResult, 4) < 0) { if (rfbWriteExact(cl, (char *)&authResult, 4) < 0) {
rfbLogPerror("rfbAuthProcessClientMessage: write"); rfbLogPerror("rfbAuthProcessClientMessage: write");
} }
rfbCloseClient(cl); /* support RFB 3.8 clients, they expect a reason *why* it was disconnected */
if (cl->protocolMinorVersion > 7) {
rfbClientConnFailed(cl, "password check failed!");
}
else
rfbCloseClient(cl);
return; return;
} }

8
libvncserver/corre.c
Unescape View File

@ -41,7 +41,7 @@ static char *rreBeforeBuf = NULL;
static int rreAfterBufSize = 0; static int rreAfterBufSize = 0;
static char *rreAfterBuf = NULL; static char *rreAfterBuf = NULL;
static int rreAfterBufLen; static int rreAfterBufLen = 0;
static int subrectEncode8(uint8_t *data, int w, int h); static int subrectEncode8(uint8_t *data, int w, int h);
static int subrectEncode16(uint16_t *data, int w, int h); static int subrectEncode16(uint16_t *data, int w, int h);
@ -145,9 +145,9 @@ rfbSendSmallRectEncodingCoRRE(rfbClientPtr cl,
return rfbSendRectEncodingRaw(cl, x, y, w, h); return rfbSendRectEncodingRaw(cl, x, y, w, h);
} }
cl->rectanglesSent[rfbEncodingCoRRE]++; rfbStatRecordEncodingSent(cl,rfbEncodingCoRRE,
cl->bytesSent[rfbEncodingCoRRE] += (sz_rfbFramebufferUpdateRectHeader sz_rfbFramebufferUpdateRectHeader + sz_rfbRREHeader + rreAfterBufLen,
+ sz_rfbRREHeader + rreAfterBufLen); sz_rfbFramebufferUpdateRectHeader + w * h * (cl->format.bitsPerPixel / 8));
if (cl->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbRREHeader if (cl->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbRREHeader
> UPDATE_BUF_SIZE) > UPDATE_BUF_SIZE)

11
libvncserver/cursor.c
Unescape View File

@ -78,9 +78,6 @@ rfbSendCursorShape(rfbClientPtr cl)
sz_rfbFramebufferUpdateRectHeader); sz_rfbFramebufferUpdateRectHeader);
cl->ublen += sz_rfbFramebufferUpdateRectHeader; cl->ublen += sz_rfbFramebufferUpdateRectHeader;
cl->cursorShapeBytesSent += sz_rfbFramebufferUpdateRectHeader;
cl->cursorShapeUpdatesSent++;
if (!rfbSendUpdateBuf(cl)) if (!rfbSendUpdateBuf(cl))
return FALSE; return FALSE;
@ -167,9 +164,8 @@ rfbSendCursorShape(rfbClientPtr cl)
} }
/* Send everything we have prepared in the cl->updateBuf[]. */ /* Send everything we have prepared in the cl->updateBuf[]. */
rfbStatRecordMessageSent(cl, (cl->useRichCursorEncoding ? rfbEncodingRichCursor : rfbEncodingXCursor),
cl->cursorShapeBytesSent += (cl->ublen - saved_ublen); sz_rfbFramebufferUpdateRectHeader + (cl->ublen - saved_ublen), sz_rfbFramebufferUpdateRectHeader + (cl->ublen - saved_ublen));
cl->cursorShapeUpdatesSent++;
if (!rfbSendUpdateBuf(cl)) if (!rfbSendUpdateBuf(cl))
return FALSE; return FALSE;
@ -201,8 +197,7 @@ rfbSendCursorPos(rfbClientPtr cl)
sz_rfbFramebufferUpdateRectHeader); sz_rfbFramebufferUpdateRectHeader);
cl->ublen += sz_rfbFramebufferUpdateRectHeader; cl->ublen += sz_rfbFramebufferUpdateRectHeader;
cl->cursorPosBytesSent += sz_rfbFramebufferUpdateRectHeader; rfbStatRecordMessageSent(cl, rfbEncodingPointerPos, sz_rfbFramebufferUpdateRectHeader, sz_rfbFramebufferUpdateRectHeader);
cl->cursorPosUpdatesSent++;
if (!rfbSendUpdateBuf(cl)) if (!rfbSendUpdateBuf(cl))
return FALSE; return FALSE;

17
libvncserver/hextile.c
Unescape View File

@ -44,7 +44,7 @@ rfbSendRectEncodingHextile(rfbClientPtr cl,
int h) int h)
{ {
rfbFramebufferUpdateRectHeader rect; rfbFramebufferUpdateRectHeader rect;
if (cl->ublen + sz_rfbFramebufferUpdateRectHeader > UPDATE_BUF_SIZE) { if (cl->ublen + sz_rfbFramebufferUpdateRectHeader > UPDATE_BUF_SIZE) {
if (!rfbSendUpdateBuf(cl)) if (!rfbSendUpdateBuf(cl))
return FALSE; return FALSE;
@ -60,8 +60,9 @@ rfbSendRectEncodingHextile(rfbClientPtr cl,
sz_rfbFramebufferUpdateRectHeader); sz_rfbFramebufferUpdateRectHeader);
cl->ublen += sz_rfbFramebufferUpdateRectHeader; cl->ublen += sz_rfbFramebufferUpdateRectHeader;
cl->rectanglesSent[rfbEncodingHextile]++; rfbStatRecordEncodingSent(cl, rfbEncodingHextile,
cl->bytesSent[rfbEncodingHextile] += sz_rfbFramebufferUpdateRectHeader; sz_rfbFramebufferUpdateRectHeader,
sz_rfbFramebufferUpdateRectHeader + w * (cl->format.bitsPerPixel / 8) * h);
switch (cl->format.bitsPerPixel) { switch (cl->format.bitsPerPixel) {
case 8: case 8:
@ -136,6 +137,7 @@ sendHextiles##bpp(rfbClientPtr cl, int rx, int ry, int rw, int rh) {
startUblen = cl->ublen; \ startUblen = cl->ublen; \
cl->updateBuf[startUblen] = 0; \ cl->updateBuf[startUblen] = 0; \
cl->ublen++; \ cl->ublen++; \
rfbStatRecordEncodingSentAdd(cl, rfbEncodingHextile, 1); \
\ \
testColours##bpp(clientPixelData, w * h, \ testColours##bpp(clientPixelData, w * h, \
&mono, &solid, &newBg, &newFg); \ &mono, &solid, &newBg, &newFg); \
@ -148,7 +150,6 @@ sendHextiles##bpp(rfbClientPtr cl, int rx, int ry, int rw, int rh) {
} \ } \
\ \
if (solid) { \ if (solid) { \
cl->bytesSent[rfbEncodingHextile] += cl->ublen - startUblen; \
continue; \ continue; \
} \ } \
\ \
@ -175,15 +176,15 @@ sendHextiles##bpp(rfbClientPtr cl, int rx, int ry, int rw, int rh) {
(*cl->translateFn)(cl->translateLookupTable, \ (*cl->translateFn)(cl->translateLookupTable, \
&(cl->screen->serverFormat), &cl->format, fbptr, \ &(cl->screen->serverFormat), &cl->format, fbptr, \
(char *)clientPixelData, \ (char *)clientPixelData, \
cl->scaledScreen->paddedWidthInBytes, w, h); \ cl->scaledScreen->paddedWidthInBytes, w, h); \
\ \
memcpy(&cl->updateBuf[cl->ublen], (char *)clientPixelData, \ memcpy(&cl->updateBuf[cl->ublen], (char *)clientPixelData, \
w * h * (bpp/8)); \ w * h * (bpp/8)); \
\ \
cl->ublen += w * h * (bpp/8); \ cl->ublen += w * h * (bpp/8); \
rfbStatRecordEncodingSentAdd(cl, rfbEncodingHextile, \
w * h * (bpp/8)); \
} \ } \
\
cl->bytesSent[rfbEncodingHextile] += cl->ublen - startUblen; \
} \ } \
} \ } \
\ \
@ -210,6 +211,7 @@ subrectEncode##bpp(rfbClientPtr cl, uint##bpp##_t *data, int w, int h,
\ \
nSubrectsUblen = cl->ublen; \ nSubrectsUblen = cl->ublen; \
cl->ublen++; \ cl->ublen++; \
rfbStatRecordEncodingSentAdd(cl, rfbEncodingHextile, 1); \
\ \
for (y=0; y<h; y++) { \ for (y=0; y<h; y++) { \
line = data+(y*w); \ line = data+(y*w); \
@ -268,6 +270,7 @@ subrectEncode##bpp(rfbClientPtr cl, uint##bpp##_t *data, int w, int h,
\ \
cl->updateBuf[cl->ublen++] = rfbHextilePackXY(thex,they); \ cl->updateBuf[cl->ublen++] = rfbHextilePackXY(thex,they); \
cl->updateBuf[cl->ublen++] = rfbHextilePackWH(thew,theh); \ cl->updateBuf[cl->ublen++] = rfbHextilePackWH(thew,theh); \
rfbStatRecordEncodingSentAdd(cl, rfbEncodingHextile, 1); \
\ \
/* \ /* \
* Now mark the subrect as done. \ * Now mark the subrect as done. \

32
libvncserver/main.c
Unescape View File

@ -495,22 +495,40 @@ clientInput(void *data)
pthread_create(&output_thread, NULL, clientOutput, (void *)cl); pthread_create(&output_thread, NULL, clientOutput, (void *)cl);
while (1) { while (1) {
fd_set fds; fd_set rfds, wfds, efds;
struct timeval tv; struct timeval tv;
int n; int n;
FD_ZERO(&fds); FD_ZERO(&rfds);
FD_SET(cl->sock, &fds); FD_SET(cl->sock, &rfds);
FD_ZERO(&efds);
FD_SET(cl->sock, &efds);
/* Are we transferring a file in the background? */
FD_ZERO(&wfds);
if ((cl->fileTransfer.fd!=-1) && (cl->fileTransfer.sending==1))
FD_SET(cl->sock, &wfds);
tv.tv_sec = 60; /* 1 minute */ tv.tv_sec = 60; /* 1 minute */
tv.tv_usec = 0; tv.tv_usec = 0;
n = select(cl->sock + 1, &fds, NULL, &fds, &tv); n = select(cl->sock + 1, &rfds, &wfds, &efds, &tv);
if (n < 0) { if (n < 0) {
rfbLogPerror("ReadExact: select"); rfbLogPerror("ReadExact: select");
break; break;
} }
if (n == 0) /* timeout */ if (n == 0) /* timeout */
{
rfbSendFileTransferChunk(cl);
continue; continue;
rfbProcessClientMessage(cl); }
/* We have some space on the transmit queue, send some data */
if (FD_ISSET(cl->sock, &wfds))
rfbSendFileTransferChunk(cl);
if (FD_ISSET(cl->sock, &rfds) || FD_ISSET(cl->sock, &efds))
rfbProcessClientMessage(cl);
if (cl->sock == -1) { if (cl->sock == -1) {
/* Client has disconnected. */ /* Client has disconnected. */
break; break;
@ -818,6 +836,10 @@ rfbScreenInfoPtr rfbGetScreen(int* argc,char** argv,
screen->handleEventsEagerly = FALSE; screen->handleEventsEagerly = FALSE;
/* Emulate UltraVNC Server by default */
screen->protocolMajorVersion = 3;
screen->protocolMinorVersion = 6;
if(!rfbProcessArguments(screen,argc,argv)) { if(!rfbProcessArguments(screen,argc,argv)) {
free(screen); free(screen);
return NULL; return NULL;

1013
libvncserver/rfbserver.c
View File

File diff suppressed because it is too large Load Diff

8
libvncserver/rre.c
Unescape View File

@ -40,7 +40,7 @@ static char *rreBeforeBuf = NULL;
static int rreAfterBufSize = 0; static int rreAfterBufSize = 0;
static char *rreAfterBuf = NULL; static char *rreAfterBuf = NULL;
static int rreAfterBufLen; static int rreAfterBufLen=0;
static int subrectEncode8(uint8_t *data, int w, int h); static int subrectEncode8(uint8_t *data, int w, int h);
static int subrectEncode16(uint16_t *data, int w, int h); static int subrectEncode16(uint16_t *data, int w, int h);
@ -112,9 +112,9 @@ rfbSendRectEncodingRRE(rfbClientPtr cl,
return rfbSendRectEncodingRaw(cl, x, y, w, h); return rfbSendRectEncodingRaw(cl, x, y, w, h);
} }
cl->rectanglesSent[rfbEncodingRRE]++; rfbStatRecordEncodingSent(cl, rfbEncodingRRE,
cl->bytesSent[rfbEncodingRRE] += (sz_rfbFramebufferUpdateRectHeader sz_rfbFramebufferUpdateRectHeader + sz_rfbRREHeader + rreAfterBufLen,
+ sz_rfbRREHeader + rreAfterBufLen); sz_rfbFramebufferUpdateRectHeader + w * h * (cl->format.bitsPerPixel / 8));
if (cl->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbRREHeader if (cl->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbRREHeader
> UPDATE_BUF_SIZE) > UPDATE_BUF_SIZE)

8
libvncserver/scale.c
Unescape View File

@ -128,8 +128,8 @@ void rfbScaledCorrection(rfbScreenInfoPtr from, rfbScreenInfoPtr to, int *x, int
*h = (int)h2; *h = (int)h2;
/* Small changes for a thumbnail may be scaled to zero */ /* Small changes for a thumbnail may be scaled to zero */
if (*w==0) *w++; if (*w==0) (*w)++;
if (*h==0) *h++; if (*h==0) (*h)++;
/* scaling from small to big may overstep the size a bit */ /* scaling from small to big may overstep the size a bit */
if (*x+*w > to->width) *w=to->width - *x; if (*x+*w > to->width) *w=to->width - *x;
if (*y+*h > to->height) *h=to->height - *y; if (*y+*h > to->height) *h=to->height - *y;
@ -212,7 +212,9 @@ void rfbScaledScreenUpdateRect(rfbScreenInfoPtr screen, rfbScreenInfoPtr ptr, in
pixel_value += (srcptr2[z] << (8 * z)); pixel_value += (srcptr2[z] << (8 * z));
break; break;
} }
//srcptr2 += bytesPerPixel; /*
srcptr2 += bytesPerPixel;
*/
red += ((pixel_value >> redShift) & redMax); red += ((pixel_value >> redShift) & redMax);
green += ((pixel_value >> greenShift) & greenMax); green += ((pixel_value >> greenShift) & greenMax);

22
libvncserver/sockets.c
Unescape View File

@ -239,8 +239,18 @@ rfbCheckFds(rfbScreenInfoPtr rfbScreen,long usec)
tv.tv_usec = usec; tv.tv_usec = usec;
nfds = select(rfbScreen->maxFd + 1, &fds, NULL, NULL /* &fds */, &tv); nfds = select(rfbScreen->maxFd + 1, &fds, NULL, NULL /* &fds */, &tv);
if (nfds == 0) { if (nfds == 0) {
/* timed out, check for async events */
i = rfbGetClientIterator(rfbScreen);
while((cl = rfbClientIteratorNext(i))) {
if (cl->onHold)
continue;
if (FD_ISSET(cl->sock, &(rfbScreen->allFds)))
rfbSendFileTransferChunk(cl);
}
rfbReleaseClientIterator(i);
return result; return result;
} }
if (nfds < 0) { if (nfds < 0) {
#ifdef WIN32 #ifdef WIN32
errno = WSAGetLastError(); errno = WSAGetLastError();
@ -332,11 +342,17 @@ rfbCheckFds(rfbScreenInfoPtr rfbScreen,long usec)
i = rfbGetClientIterator(rfbScreen); i = rfbGetClientIterator(rfbScreen);
while((cl = rfbClientIteratorNext(i))) { while((cl = rfbClientIteratorNext(i))) {
if (cl->onHold) if (cl->onHold)
continue; continue;
if (FD_ISSET(cl->sock, &fds) &&
FD_ISSET(cl->sock, &(rfbScreen->allFds))) if (FD_ISSET(cl->sock, &(rfbScreen->allFds)))
rfbProcessClientMessage(cl); {
if (FD_ISSET(cl->sock, &fds))
rfbProcessClientMessage(cl);
else
rfbSendFileTransferChunk(cl);
}
} }
rfbReleaseClientIterator(i); rfbReleaseClientIterator(i);
} while(rfbScreen->handleEventsEagerly); } while(rfbScreen->handleEventsEagerly);

476
libvncserver/stats.c
Unescape View File

@ -26,90 +26,434 @@
#include <rfb/rfb.h> #include <rfb/rfb.h>
static const char* encNames[] = { char *messageNameServer2Client(uint32_t type, char *buf, int len);
"raw", "copyRect", "RRE", "[encoding 3]", "CoRRE", "hextile", char *messageNameClient2Server(uint32_t type, char *buf, int len);
"zlib", "tight", "[encoding 8]", "ultra", "[encoding 10]", char *encodingName(uint32_t enc, char *buf, int len);
"[encoding 11]", "[encoding 12]", "[encoding 13]", "[encoding 14]",
"[encoding 15]",
"ZRLE", "[encoding 17]", "[encoding 18]", "[encoding 19]", "[encoding 20]"
};
rfbStatList *rfbStatLookupEncoding(rfbClientPtr cl, uint32_t type);
rfbStatList *rfbStatLookupMessage(rfbClientPtr cl, uint32_t type);
void void rfbStatRecordEncodingSent(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw);
rfbResetStats(rfbClientPtr cl) void rfbStatRecordEncodingRcvd(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw);
void rfbStatRecordMessageSent(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw);
void rfbStatRecordMessageRcvd(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw);
void rfbResetStats(rfbClientPtr cl);
void rfbPrintStats(rfbClientPtr cl);
char *messageNameServer2Client(uint32_t type, char *buf, int len) {
if (buf==NULL) return "error";
switch (type) {
case rfbFramebufferUpdate: snprintf(buf, len, "FramebufferUpdate"); break;
case rfbSetColourMapEntries: snprintf(buf, len, "SetColourMapEntries"); break;
case rfbBell: snprintf(buf, len, "Bell"); break;
case rfbServerCutText: snprintf(buf, len, "ServerCutText"); break;
case rfbResizeFrameBuffer: snprintf(buf, len, "ResizeFrameBuffer"); break;
case rfbKeyFrameUpdate: snprintf(buf, len, "KeyFrameUpdate"); break;
case rfbFileTransfer: snprintf(buf, len, "FileTransfer"); break;
case rfbTextChat: snprintf(buf, len, "TextChat"); break;
case rfbPalmVNCReSizeFrameBuffer: snprintf(buf, len, "PalmVNCReSize"); break;
default:
snprintf(buf, len, "server2client(0x%04X)", type);
}
return buf;
}
char *messageNameClient2Server(uint32_t type, char *buf, int len) {
if (buf==NULL) return "error";
switch (type) {
case rfbSetPixelFormat: snprintf(buf, len, "SetPixelFormat"); break;
case rfbFixColourMapEntries: snprintf(buf, len, "FixColourMapEntries"); break;
case rfbSetEncodings: snprintf(buf, len, "SetEncodings"); break;
case rfbFramebufferUpdateRequest: snprintf(buf, len, "FramebufferUpdate"); break;
case rfbKeyEvent: snprintf(buf, len, "KeyEvent"); break;
case rfbPointerEvent: snprintf(buf, len, "PointerEvent"); break;
case rfbClientCutText: snprintf(buf, len, "ClientCutText"); break;
case rfbFileTransfer: snprintf(buf, len, "FileTransfer"); break;
case rfbSetScale: snprintf(buf, len, "SetScale"); break;
case rfbSetServerInput: snprintf(buf, len, "SetServerInput"); break;
case rfbSetSW: snprintf(buf, len, "SetSingleWindow"); break;
case rfbTextChat: snprintf(buf, len, "TextChat"); break;
case rfbKeyFrameRequest: snprintf(buf, len, "KeyFrameRequest"); break;
case rfbPalmVNCSetScaleFactor: snprintf(buf, len, "PalmVNCSetScale"); break;
default:
snprintf(buf, len, "client2server(0x%04X)", type);
}
return buf;
}
char *encodingName(uint32_t type, char *buf, int len) {
if (buf==NULL) return "error";
switch (type) {
case rfbEncodingRaw: snprintf(buf, len, "raw"); break;
case rfbEncodingCopyRect: snprintf(buf, len, "copyRect"); break;
case rfbEncodingRRE: snprintf(buf, len, "RRE"); break;
case rfbEncodingCoRRE: snprintf(buf, len, "CoRRE"); break;
case rfbEncodingHextile: snprintf(buf, len, "hextile"); break;
case rfbEncodingZlib: snprintf(buf, len, "zlib"); break;
case rfbEncodingTight: snprintf(buf, len, "tight"); break;
case rfbEncodingZlibHex: snprintf(buf, len, "zlibhex"); break;
case rfbEncodingUltra: snprintf(buf, len, "ultra"); break;
case rfbEncodingZRLE: snprintf(buf, len, "ZRLE"); break;
case rfbEncodingCache: snprintf(buf, len, "cache"); break;
case rfbEncodingCacheEnable: snprintf(buf, len, "cacheEnable"); break;
case rfbEncodingXOR_Zlib: snprintf(buf, len, "xorZlib"); break;
case rfbEncodingXORMonoColor_Zlib: snprintf(buf, len, "xorMonoZlib"); break;
case rfbEncodingXORMultiColor_Zlib: snprintf(buf, len, "xorColorZlib"); break;
case rfbEncodingSolidColor: snprintf(buf, len, "solidColor"); break;
case rfbEncodingXOREnable: snprintf(buf, len, "xorEnable"); break;
case rfbEncodingCacheZip: snprintf(buf, len, "cacheZip"); break;
case rfbEncodingSolMonoZip: snprintf(buf, len, "monoZip"); break;
case rfbEncodingUltraZip: snprintf(buf, len, "ultraZip"); break;
case rfbEncodingXCursor: snprintf(buf, len, "Xcursor"); break;
case rfbEncodingRichCursor: snprintf(buf, len, "RichCursor"); break;
case rfbEncodingPointerPos: snprintf(buf, len, "PointerPos"); break;
case rfbEncodingLastRect: snprintf(buf, len, "LastRect"); break;
case rfbEncodingNewFBSize: snprintf(buf, len, "NewFBSize"); break;
case rfbEncodingKeyboardLedState: snprintf(buf, len, "LedState"); break;
case rfbEncodingSupportedMessages: snprintf(buf, len, "SupportedMessages"); break;
case rfbEncodingSupportedEncodings: snprintf(buf, len, "SupportedEncodings"); break;
case rfbEncodingServerIdentity: snprintf(buf, len, "ServerIdentity"); break;
case rfbEncodingCompressLevel0: snprintf(buf, len, "CompressLevel0"); break;
case rfbEncodingCompressLevel1: snprintf(buf, len, "CompressLevel1"); break;
case rfbEncodingCompressLevel2: snprintf(buf, len, "CompressLevel2"); break;
case rfbEncodingCompressLevel3: snprintf(buf, len, "CompressLevel3"); break;
case rfbEncodingCompressLevel4: snprintf(buf, len, "CompressLevel4"); break;
case rfbEncodingCompressLevel5: snprintf(buf, len, "CompressLevel5"); break;
case rfbEncodingCompressLevel6: snprintf(buf, len, "CompressLevel6"); break;
case rfbEncodingCompressLevel7: snprintf(buf, len, "CompressLevel7"); break;
case rfbEncodingCompressLevel8: snprintf(buf, len, "CompressLevel8"); break;
case rfbEncodingCompressLevel9: snprintf(buf, len, "CompressLevel9"); break;
case rfbEncodingQualityLevel0: snprintf(buf, len, "QualityLevel0"); break;
case rfbEncodingQualityLevel1: snprintf(buf, len, "QualityLevel1"); break;
case rfbEncodingQualityLevel2: snprintf(buf, len, "QualityLevel2"); break;
case rfbEncodingQualityLevel3: snprintf(buf, len, "QualityLevel3"); break;
case rfbEncodingQualityLevel4: snprintf(buf, len, "QualityLevel4"); break;
case rfbEncodingQualityLevel5: snprintf(buf, len, "QualityLevel5"); break;
case rfbEncodingQualityLevel6: snprintf(buf, len, "QualityLevel6"); break;
case rfbEncodingQualityLevel7: snprintf(buf, len, "QualityLevel7"); break;
case rfbEncodingQualityLevel8: snprintf(buf, len, "QualityLevel8"); break;
case rfbEncodingQualityLevel9: snprintf(buf, len, "QualityLevel9"); break;
default:
snprintf(buf, len, "encoding(0x%04X)", type);
}
return buf;
}
rfbStatList *rfbStatLookupEncoding(rfbClientPtr cl, uint32_t type)
{ {
int i; rfbStatList *ptr;
for (i = 0; i < MAX_ENCODINGS; i++) { if (cl==NULL) return NULL;
cl->bytesSent[i] = 0; for (ptr = cl->statEncList; ptr!=NULL; ptr=ptr->Next)
cl->rectanglesSent[i] = 0; {
if (ptr->type==type) return ptr;
}
/* Well, we are here... need to *CREATE* an entry */
ptr = (rfbStatList *)malloc(sizeof(rfbStatList));
if (ptr!=NULL)
{
memset((char *)ptr, 0, sizeof(rfbStatList));
ptr->type = type;
/* add to the top of the list */
ptr->Next = cl->statEncList;
cl->statEncList = ptr;
} }
cl->lastRectMarkersSent = 0; return ptr;
cl->lastRectBytesSent = 0;
cl->cursorShapeBytesSent = 0;
cl->cursorShapeUpdatesSent = 0;
cl->cursorPosBytesSent = 0;
cl->cursorPosUpdatesSent = 0;
cl->framebufferUpdateMessagesSent = 0;
cl->rawBytesEquivalent = 0;
cl->keyEventsRcvd = 0;
cl->pointerEventsRcvd = 0;
} }
void
rfbPrintStats(rfbClientPtr cl) rfbStatList *rfbStatLookupMessage(rfbClientPtr cl, uint32_t type)
{ {
int i; rfbStatList *ptr;
int totalRectanglesSent = 0; if (cl==NULL) return NULL;
int totalBytesSent = 0; for (ptr = cl->statMsgList; ptr!=NULL; ptr=ptr->Next)
{
if (ptr->type==type) return ptr;
}
/* Well, we are here... need to *CREATE* an entry */
ptr = (rfbStatList *)malloc(sizeof(rfbStatList));
if (ptr!=NULL)
{
memset((char *)ptr, 0, sizeof(rfbStatList));
ptr->type = type;
/* add to the top of the list */
ptr->Next = cl->statMsgList;
cl->statMsgList = ptr;
}
return ptr;
}
rfbLog("Statistics:\n"); void rfbStatRecordEncodingSentAdd(rfbClientPtr cl, uint32_t type, int byteCount) /* Specifically for tight encoding */
{
rfbStatList *ptr;
if ((cl->keyEventsRcvd != 0) || (cl->pointerEventsRcvd != 0)) ptr = rfbStatLookupEncoding(cl, type);
rfbLog(" key events received %d, pointer events %d\n", if (ptr!=NULL)
cl->keyEventsRcvd, cl->pointerEventsRcvd); ptr->bytesSent += byteCount;
}
for (i = 0; i < MAX_ENCODINGS; i++) {
totalRectanglesSent += cl->rectanglesSent[i]; void rfbStatRecordEncodingSent(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw)
totalBytesSent += cl->bytesSent[i]; {
rfbStatList *ptr;
ptr = rfbStatLookupEncoding(cl, type);
if (ptr!=NULL)
{
ptr->sentCount++;
ptr->bytesSent += byteCount;
ptr->bytesSentIfRaw += byteIfRaw;
} }
}
totalRectanglesSent += (cl->cursorShapeUpdatesSent + void rfbStatRecordEncodingRcvd(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw)
cl->cursorPosUpdatesSent + {
cl->lastRectMarkersSent); rfbStatList *ptr;
totalBytesSent += (cl->cursorShapeBytesSent +
cl->cursorPosBytesSent +
cl->lastRectBytesSent);
rfbLog(" framebuffer updates %d, rectangles %d, bytes %d\n", ptr = rfbStatLookupEncoding(cl, type);
cl->framebufferUpdateMessagesSent, totalRectanglesSent, if (ptr!=NULL)
totalBytesSent); {
ptr->rcvdCount++;
ptr->bytesRcvd += byteCount;
ptr->bytesRcvdIfRaw += byteIfRaw;
}
}
if (cl->lastRectMarkersSent != 0) void rfbStatRecordMessageSent(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw)
rfbLog(" LastRect and NewFBSize markers %d, bytes %d\n", {
cl->lastRectMarkersSent, cl->lastRectBytesSent); rfbStatList *ptr;
if (cl->cursorShapeUpdatesSent != 0) ptr = rfbStatLookupMessage(cl, type);
rfbLog(" cursor shape updates %d, bytes %d\n", if (ptr!=NULL)
cl->cursorShapeUpdatesSent, cl->cursorShapeBytesSent); {
ptr->sentCount++;
ptr->bytesSent += byteCount;
ptr->bytesSentIfRaw += byteIfRaw;
}
}
if (cl->cursorPosUpdatesSent != 0) void rfbStatRecordMessageRcvd(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw)
rfbLog(" cursor position updates %d, bytes %d\n", {
cl->cursorPosUpdatesSent, cl->cursorPosBytesSent); rfbStatList *ptr;
for (i = 0; i < MAX_ENCODINGS; i++) { ptr = rfbStatLookupMessage(cl, type);
if (cl->rectanglesSent[i] != 0) if (ptr!=NULL)
rfbLog(" %s rectangles %d, bytes %d\n", {
encNames[i], cl->rectanglesSent[i], cl->bytesSent[i]); ptr->rcvdCount++;
ptr->bytesRcvd += byteCount;
ptr->bytesRcvdIfRaw += byteIfRaw;
} }
}
int rfbStatGetSentBytes(rfbClientPtr cl)
{
rfbStatList *ptr=NULL;
int bytes=0;
if (cl==NULL) return 0;
for (ptr = cl->statMsgList; ptr!=NULL; ptr=ptr->Next)
bytes += ptr->bytesSent;
for (ptr = cl->statEncList; ptr!=NULL; ptr=ptr->Next)
bytes += ptr->bytesSent;
return bytes;
}
int rfbStatGetSentBytesIfRaw(rfbClientPtr cl)
{
rfbStatList *ptr=NULL;
int bytes=0;
if (cl==NULL) return 0;
for (ptr = cl->statMsgList; ptr!=NULL; ptr=ptr->Next)
bytes += ptr->bytesSentIfRaw;
for (ptr = cl->statEncList; ptr!=NULL; ptr=ptr->Next)
bytes += ptr->bytesSentIfRaw;
return bytes;
}
int rfbStatGetRcvdBytes(rfbClientPtr cl)
{
rfbStatList *ptr=NULL;
int bytes=0;
if (cl==NULL) return 0;
for (ptr = cl->statMsgList; ptr!=NULL; ptr=ptr->Next)
bytes += ptr->bytesRcvd;
for (ptr = cl->statEncList; ptr!=NULL; ptr=ptr->Next)
bytes += ptr->bytesRcvd;
return bytes;
}
int rfbStatGetRcvdBytesIfRaw(rfbClientPtr cl)
{
rfbStatList *ptr=NULL;
int bytes=0;
if (cl==NULL) return 0;
for (ptr = cl->statMsgList; ptr!=NULL; ptr=ptr->Next)
bytes += ptr->bytesRcvdIfRaw;
for (ptr = cl->statEncList; ptr!=NULL; ptr=ptr->Next)
bytes += ptr->bytesRcvdIfRaw;
return bytes;
}
int rfbStatGetMessageCountSent(rfbClientPtr cl, uint32_t type)
{
rfbStatList *ptr=NULL;
if (cl==NULL) return 0;
for (ptr = cl->statMsgList; ptr!=NULL; ptr=ptr->Next)
if (ptr->type==type) return ptr->sentCount;
return 0;
}
int rfbStatGetMessageCountRcvd(rfbClientPtr cl, uint32_t type)
{
rfbStatList *ptr=NULL;
if (cl==NULL) return 0;
for (ptr = cl->statMsgList; ptr!=NULL; ptr=ptr->Next)
if (ptr->type==type) return ptr->rcvdCount;
return 0;
}
int rfbStatGetEncodingCountSent(rfbClientPtr cl, uint32_t type)
{
rfbStatList *ptr=NULL;
if (cl==NULL) return 0;
for (ptr = cl->statEncList; ptr!=NULL; ptr=ptr->Next)
if (ptr->type==type) return ptr->sentCount;
return 0;
}
int rfbStatGetEncodingCountRcvd(rfbClientPtr cl, uint32_t type)
{
rfbStatList *ptr=NULL;
if (cl==NULL) return 0;
for (ptr = cl->statEncList; ptr!=NULL; ptr=ptr->Next)
if (ptr->type==type) return ptr->rcvdCount;
return 0;
}
if ((totalBytesSent - cl->bytesSent[rfbEncodingCopyRect]) != 0) {
rfbLog(" raw bytes equivalent %d, compression ratio %f\n", void rfbResetStats(rfbClientPtr cl)
cl->rawBytesEquivalent, {
(double)cl->rawBytesEquivalent rfbStatList *ptr;
/ (double)(totalBytesSent if (cl==NULL) return;
- cl->bytesSent[rfbEncodingCopyRect]- while (cl->statEncList!=NULL)
cl->cursorShapeBytesSent - {
cl->cursorPosBytesSent - ptr = cl->statEncList;
cl->lastRectBytesSent)); cl->statEncList = ptr->Next;
free(ptr);
}
while (cl->statMsgList!=NULL)
{
ptr = cl->statMsgList;
cl->statMsgList = ptr->Next;
free(ptr);
} }
} }
void rfbPrintStats(rfbClientPtr cl)
{
rfbStatList *ptr=NULL;
char encBuf[64];
double savings=0.0;
int totalRectsSent=0;
double totalBytesSent=0.0;
double totalBytesIfRawSent=0.0;
int totalRectsRcvd=0;
double totalBytesRcvd=0.0;
double totalBytesIfRawRcvd=0.0;
char *name=NULL;
int bytes=0;
int count=0;
if (cl==NULL) return;
rfbLog("Statistics: Transmit\n");
for (ptr = cl->statMsgList; ptr!=NULL; ptr=ptr->Next)
{
name = messageNameServer2Client(ptr->type, encBuf, sizeof(encBuf));
count = ptr->sentCount;
bytes = ptr->bytesSent;
savings = 0.0;
if (ptr->bytesSentIfRaw>0.0)
savings = 100.0 - (((double)ptr->bytesSent / (double)ptr->bytesSentIfRaw) * 100.0);
if ((bytes>0) || (count>0))
rfbLog(" %-24.24s: %6d events %9d/%9d bytes (%5.2f%% saved)\n",
name, count, bytes, ptr->bytesSentIfRaw, savings);
totalRectsSent += count;
totalBytesSent += bytes;
totalBytesIfRawSent += ptr->bytesSentIfRaw;
}
for (ptr = cl->statEncList; ptr!=NULL; ptr=ptr->Next)
{
name = encodingName(ptr->type, encBuf, sizeof(encBuf));
count = ptr->sentCount;
bytes = ptr->bytesSent;
savings = 0.0;
if (ptr->bytesSentIfRaw>0.0)
savings = 100.0 - (((double)ptr->bytesSent / (double)ptr->bytesSentIfRaw) * 100.0);
if ((bytes>0) || (count>0))
rfbLog(" %-24.24s: %6d events %9d/%9d bytes (%5.2f%% saved)\n",
name, count, bytes, ptr->bytesSentIfRaw, savings);
totalRectsSent += count;
totalBytesSent += bytes;
totalBytesIfRawSent += ptr->bytesSentIfRaw;
}
savings = 100.0 - ((totalBytesSent/totalBytesIfRawSent)*100.0);
rfbLog(" %-24.24s: %6d events %9.0f/%9.0f bytes (%5.2f%% savings)\n",
"TOTALS", totalRectsSent, totalBytesSent, totalBytesIfRawSent, savings);
rfbLog("Statistics: Receive\n");
for (ptr = cl->statMsgList; ptr!=NULL; ptr=ptr->Next)
{
name = messageNameClient2Server(ptr->type, encBuf, sizeof(encBuf));
count = ptr->rcvdCount;
bytes = ptr->bytesRcvd;
savings = 0.0;
if (ptr->bytesSentIfRaw>0.0)
savings = 100.0 - (((double)ptr->bytesRcvd / (double)ptr->bytesRcvdIfRaw) * 100.0);
if ((bytes>0) || (count>0))
rfbLog(" %-24.24s: %6d events %9d/%9d bytes (%5.2f%% saved)\n",
name, count, bytes, ptr->bytesRcvdIfRaw, savings);
totalRectsRcvd += count;
totalBytesRcvd += bytes;
totalBytesIfRawRcvd += ptr->bytesRcvdIfRaw;
}
for (ptr = cl->statEncList; ptr!=NULL; ptr=ptr->Next)
{
name = encodingName(ptr->type, encBuf, sizeof(encBuf));
count = ptr->rcvdCount;
bytes = ptr->bytesRcvd;
savings = 0.0;
if (ptr->bytesSentIfRaw>0.0)
savings = 100.0 - (((double)ptr->bytesRcvd / (double)ptr->bytesRcvdIfRaw) * 100.0);
if ((bytes>0) || (count>0))
rfbLog(" %-24.24s: %6d events %9d/%9d bytes (%5.2f%% saved)\n",
name, count, bytes, ptr->bytesRcvdIfRaw, savings);
totalRectsRcvd += count;
totalBytesRcvd += bytes;
totalBytesIfRawRcvd += ptr->bytesRcvdIfRaw;
}
savings = 100.0 - ((totalBytesRcvd/totalBytesIfRawRcvd)*100.0);
rfbLog(" %-24.24s: %6d events %9.0f/%9.0f bytes (%5.2f%% savings)\n",
"TOTALS", totalRectsRcvd, totalBytesRcvd,totalBytesIfRawRcvd, savings);
}

32
libvncserver/tight.c
Unescape View File

@ -663,8 +663,8 @@ SendTightHeader(rfbClientPtr cl,
sz_rfbFramebufferUpdateRectHeader); sz_rfbFramebufferUpdateRectHeader);
cl->ublen += sz_rfbFramebufferUpdateRectHeader; cl->ublen += sz_rfbFramebufferUpdateRectHeader;
cl->rectanglesSent[rfbEncodingTight]++; rfbStatRecordEncodingSent(cl, rfbEncodingTight, sz_rfbFramebufferUpdateRectHeader,
cl->bytesSent[rfbEncodingTight] += sz_rfbFramebufferUpdateRectHeader; sz_rfbFramebufferUpdateRectHeader + w * (cl->format.bitsPerPixel / 8) * h);
return TRUE; return TRUE;
} }
@ -693,7 +693,7 @@ SendSolidRect(rfbClientPtr cl)
memcpy (&cl->updateBuf[cl->ublen], tightBeforeBuf, len); memcpy (&cl->updateBuf[cl->ublen], tightBeforeBuf, len);
cl->ublen += len; cl->ublen += len;
cl->bytesSent[rfbEncodingTight] += len + 1; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, len+1);
return TRUE; return TRUE;
} }
@ -736,7 +736,7 @@ SendMonoRect(rfbClientPtr cl,
memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, paletteLen); memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, paletteLen);
cl->ublen += paletteLen; cl->ublen += paletteLen;
cl->bytesSent[rfbEncodingTight] += 3 + paletteLen; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 3 + paletteLen);
break; break;
case 16: case 16:
@ -747,7 +747,7 @@ SendMonoRect(rfbClientPtr cl,
memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, 4); memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, 4);
cl->ublen += 4; cl->ublen += 4;
cl->bytesSent[rfbEncodingTight] += 7; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 7);
break; break;
default: default:
@ -755,7 +755,7 @@ SendMonoRect(rfbClientPtr cl,
cl->updateBuf[cl->ublen++] = (char)monoBackground; cl->updateBuf[cl->ublen++] = (char)monoBackground;
cl->updateBuf[cl->ublen++] = (char)monoForeground; cl->updateBuf[cl->ublen++] = (char)monoForeground;
cl->bytesSent[rfbEncodingTight] += 5; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 5);
} }
return CompressData(cl, streamId, dataLen, return CompressData(cl, streamId, dataLen,
@ -801,7 +801,7 @@ SendIndexedRect(rfbClientPtr cl,
memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, paletteNumColors * entryLen); memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, paletteNumColors * entryLen);
cl->ublen += paletteNumColors * entryLen; cl->ublen += paletteNumColors * entryLen;
cl->bytesSent[rfbEncodingTight] += 3 + paletteNumColors * entryLen; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 3 + paletteNumColors * entryLen);
break; break;
case 16: case 16:
@ -814,7 +814,7 @@ SendIndexedRect(rfbClientPtr cl,
memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, paletteNumColors * 2); memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, paletteNumColors * 2);
cl->ublen += paletteNumColors * 2; cl->ublen += paletteNumColors * 2;
cl->bytesSent[rfbEncodingTight] += 3 + paletteNumColors * 2; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 3 + paletteNumColors * 2);
break; break;
default: default:
@ -840,7 +840,7 @@ SendFullColorRect(rfbClientPtr cl,
} }
cl->updateBuf[cl->ublen++] = 0x00; /* stream id = 0, no flushing, no filter */ cl->updateBuf[cl->ublen++] = 0x00; /* stream id = 0, no flushing, no filter */
cl->bytesSent[rfbEncodingTight]++; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 1);
if (usePixelFormat24) { if (usePixelFormat24) {
Pack24(cl, tightBeforeBuf, &cl->format, w * h); Pack24(cl, tightBeforeBuf, &cl->format, w * h);
@ -874,7 +874,7 @@ SendGradientRect(rfbClientPtr cl,
cl->updateBuf[cl->ublen++] = (streamId | rfbTightExplicitFilter) << 4; cl->updateBuf[cl->ublen++] = (streamId | rfbTightExplicitFilter) << 4;
cl->updateBuf[cl->ublen++] = rfbTightFilterGradient; cl->updateBuf[cl->ublen++] = rfbTightFilterGradient;
cl->bytesSent[rfbEncodingTight] += 2; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 2);
if (usePixelFormat24) { if (usePixelFormat24) {
FilterGradient24(cl, tightBeforeBuf, &cl->format, w, h); FilterGradient24(cl, tightBeforeBuf, &cl->format, w, h);
@ -905,7 +905,7 @@ CompressData(rfbClientPtr cl,
if (dataLen < TIGHT_MIN_TO_COMPRESS) { if (dataLen < TIGHT_MIN_TO_COMPRESS) {
memcpy(&cl->updateBuf[cl->ublen], tightBeforeBuf, dataLen); memcpy(&cl->updateBuf[cl->ublen], tightBeforeBuf, dataLen);
cl->ublen += dataLen; cl->ublen += dataLen;
cl->bytesSent[rfbEncodingTight] += dataLen; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, dataLen);
return TRUE; return TRUE;
} }
@ -955,15 +955,15 @@ static rfbBool SendCompressedData(rfbClientPtr cl,
int i, portionLen; int i, portionLen;
cl->updateBuf[cl->ublen++] = compressedLen & 0x7F; cl->updateBuf[cl->ublen++] = compressedLen & 0x7F;
cl->bytesSent[rfbEncodingTight]++; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 1);
if (compressedLen > 0x7F) { if (compressedLen > 0x7F) {
cl->updateBuf[cl->ublen-1] |= 0x80; cl->updateBuf[cl->ublen-1] |= 0x80;
cl->updateBuf[cl->ublen++] = compressedLen >> 7 & 0x7F; cl->updateBuf[cl->ublen++] = compressedLen >> 7 & 0x7F;
cl->bytesSent[rfbEncodingTight]++; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 1);
if (compressedLen > 0x3FFF) { if (compressedLen > 0x3FFF) {
cl->updateBuf[cl->ublen-1] |= 0x80; cl->updateBuf[cl->ublen-1] |= 0x80;
cl->updateBuf[cl->ublen++] = compressedLen >> 14 & 0xFF; cl->updateBuf[cl->ublen++] = compressedLen >> 14 & 0xFF;
cl->bytesSent[rfbEncodingTight]++; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 1);
} }
} }
@ -979,7 +979,7 @@ static rfbBool SendCompressedData(rfbClientPtr cl,
memcpy(&cl->updateBuf[cl->ublen], &tightAfterBuf[i], portionLen); memcpy(&cl->updateBuf[cl->ublen], &tightAfterBuf[i], portionLen);
cl->ublen += portionLen; cl->ublen += portionLen;
} }
cl->bytesSent[rfbEncodingTight] += compressedLen; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, compressedLen);
return TRUE; return TRUE;
} }
@ -1686,7 +1686,7 @@ SendJpegRect(rfbClientPtr cl, int x, int y, int w, int h, int quality)
} }
cl->updateBuf[cl->ublen++] = (char)(rfbTightJpeg << 4); cl->updateBuf[cl->ublen++] = (char)(rfbTightJpeg << 4);
cl->bytesSent[rfbEncodingTight]++; rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 1);
return SendCompressedData(cl, jpegDstDataLen); return SendCompressedData(cl, jpegDstDataLen);
} }

6
libvncserver/tightvnc-filetransfer/rfbtightproto.h
Unescape View File

@ -28,6 +28,12 @@
#include <rfb/rfb.h> #include <rfb/rfb.h>
#include <limits.h> #include <limits.h>
/* PATH_MAX is not defined in limits.h on some platforms */
#ifndef PATH_MAX
#define PATH_MAX 4096
#endif
#define rfbSecTypeTight 16 #define rfbSecTypeTight 16
void rfbTightUsage(void); void rfbTightUsage(void);

4
libvncserver/ultra.c
Unescape View File

@ -101,9 +101,7 @@ rfbSendOneRectEncodingUltra(rfbClientPtr cl,
} }
/* Update statics */ /* Update statics */
cl->rectanglesSent[rfbEncodingUltra]++; rfbStatRecordEncodingSent(cl, rfbEncodingUltra, sz_rfbFramebufferUpdateRectHeader + sz_rfbZlibHeader + lzoAfterBufLen, maxRawSize);
cl->bytesSent[rfbEncodingUltra] += (sz_rfbFramebufferUpdateRectHeader
+ sz_rfbZlibHeader + lzoAfterBufLen);
if (cl->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbZlibHeader if (cl->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbZlibHeader
> UPDATE_BUF_SIZE) > UPDATE_BUF_SIZE)

6
libvncserver/zlib.c
Unescape View File

@ -121,6 +121,7 @@ rfbSendOneRectEncodingZlib(rfbClientPtr cl,
zlibAfterBuf = (char *)realloc(zlibAfterBuf, zlibAfterBufSize); zlibAfterBuf = (char *)realloc(zlibAfterBuf, zlibAfterBufSize);
} }
/* /*
* Convert pixel data to client format. * Convert pixel data to client format.
*/ */
@ -176,9 +177,8 @@ rfbSendOneRectEncodingZlib(rfbClientPtr cl,
*/ */
/* Update statics */ /* Update statics */
cl->rectanglesSent[rfbEncodingZlib]++; rfbStatRecordEncodingSent(cl, rfbEncodingZlib, sz_rfbFramebufferUpdateRectHeader + sz_rfbZlibHeader + zlibAfterBufLen,
cl->bytesSent[rfbEncodingZlib] += (sz_rfbFramebufferUpdateRectHeader + w * (cl->format.bitsPerPixel / 8) * h);
+ sz_rfbZlibHeader + zlibAfterBufLen);
if (cl->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbZlibHeader if (cl->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbZlibHeader
> UPDATE_BUF_SIZE) > UPDATE_BUF_SIZE)

5
libvncserver/zrle.c
Unescape View File

@ -124,9 +124,8 @@ rfbBool rfbSendRectEncodingZRLE(rfbClientPtr cl, int x, int y, int w, int h)
break; break;
} }
cl->rectanglesSent[rfbEncodingZRLE]++; rfbStatRecordEncodingSent(cl, rfbEncodingZRLE, sz_rfbFramebufferUpdateRectHeader + sz_rfbZRLEHeader + ZRLE_BUFFER_LENGTH(&zos->out),
cl->bytesSent[rfbEncodingZRLE] += (sz_rfbFramebufferUpdateRectHeader + w * (cl->format.bitsPerPixel / 8) * h);
+ sz_rfbZRLEHeader + ZRLE_BUFFER_LENGTH(&zos->out));
if (cl->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbZRLEHeader if (cl->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbZRLEHeader
> UPDATE_BUF_SIZE) > UPDATE_BUF_SIZE)

111
rfb/rfb.h
Unescape View File

@ -136,8 +136,22 @@ typedef rfbBool (*rfbPasswordCheckProcPtr)(struct _rfbClientRec* cl,const char*
typedef enum rfbNewClientAction (*rfbNewClientHookPtr)(struct _rfbClientRec* cl); typedef enum rfbNewClientAction (*rfbNewClientHookPtr)(struct _rfbClientRec* cl);
typedef void (*rfbDisplayHookPtr)(struct _rfbClientRec* cl); typedef void (*rfbDisplayHookPtr)(struct _rfbClientRec* cl);
/* support the capability to view the caps/num/scroll states of the X server */ /* support the capability to view the caps/num/scroll states of the X server */
typedef int (*rfbGetKeyboardLedStateHookPtr)(struct _rfbScreenInfo* screen); typedef int (*rfbGetKeyboardLedStateHookPtr)(struct _rfbScreenInfo* screen);
/* If x==1 and y==1 then set the whole display
* else find the window underneath x and y and set the framebuffer to the dimensions
* of that window
*/
typedef void (*rfbSetSingleWindowProcPtr) (struct _rfbClientRec* cl, int x, int y);
/* Status determines if the X11 server permits input from the local user
* status==0 or 1
*/
typedef void (*rfbSetServerInputProcPtr) (struct _rfbClientRec* cl, int status);
/* Permit the server to allow or deny filetransfers. This is defaulted to deny
* It is called when a client initiates a connection to determine if it is permitted.
*/
typedef int (*rfbFileTransferPermitted) (struct _rfbClientRec* cl);
/* Handle the textchat messages */
typedef void (*rfbSetTextChat) (struct _rfbClientRec* cl, int length, char *string);
typedef struct { typedef struct {
uint32_t count; uint32_t count;
@ -296,7 +310,11 @@ typedef struct _rfbScreenInfo
rfbSetXCutTextProcPtr setXCutText; rfbSetXCutTextProcPtr setXCutText;
rfbGetCursorProcPtr getCursorPtr; rfbGetCursorProcPtr getCursorPtr;
rfbSetTranslateFunctionProcPtr setTranslateFunction; rfbSetTranslateFunctionProcPtr setTranslateFunction;
rfbSetSingleWindowProcPtr setSingleWindow;
rfbSetServerInputProcPtr setServerInput;
rfbFileTransferPermitted getFileTransferPermission;
rfbSetTextChat setTextChat;
/* newClientHook is called just after a new client is created */ /* newClientHook is called just after a new client is created */
rfbNewClientHookPtr newClientHook; rfbNewClientHookPtr newClientHook;
/* displayHook is called just before a frame buffer update */ /* displayHook is called just before a frame buffer update */
@ -326,6 +344,10 @@ typedef struct _rfbScreenInfo
/* rfbEncodingServerIdentity */ /* rfbEncodingServerIdentity */
char *versionString; char *versionString;
/* What does the server tell the new clients which version it supports */
int protocolMajorVersion;
int protocolMinorVersion;
} rfbScreenInfo, *rfbScreenInfoPtr; } rfbScreenInfo, *rfbScreenInfoPtr;
@ -351,6 +373,27 @@ typedef struct sraRegion* sraRegionPtr;
typedef void (*ClientGoneHookPtr)(struct _rfbClientRec* cl); typedef void (*ClientGoneHookPtr)(struct _rfbClientRec* cl);
typedef struct _rfbFileTransferData {
int fd;
int compressionEnabled;
int fileSize;
int numPackets;
int receiving;
int sending;
} rfbFileTransferData;
typedef struct _rfbStatList {
uint32_t type;
uint32_t sentCount;
uint32_t bytesSent;
uint32_t bytesSentIfRaw;
uint32_t rcvdCount;
uint32_t bytesRcvd;
uint32_t bytesRcvdIfRaw;
struct _rfbStatList *Next;
} rfbStatList;
typedef struct _rfbClientRec { typedef struct _rfbClientRec {
/* back pointer to the screen */ /* back pointer to the screen */
@ -467,20 +510,11 @@ typedef struct _rfbClientRec {
int ublen; int ublen;
/* statistics */ /* statistics */
struct _rfbStatList *statEncList;
int bytesSent[MAX_ENCODINGS]; struct _rfbStatList *statMsgList;
int rectanglesSent[MAX_ENCODINGS];
int lastRectMarkersSent;
int lastRectBytesSent;
int cursorShapeBytesSent;
int cursorShapeUpdatesSent;
int cursorPosBytesSent;
int cursorPosUpdatesSent;
int framebufferUpdateMessagesSent;
int rawBytesEquivalent; int rawBytesEquivalent;
int keyEventsRcvd; int bytesSent;
int pointerEventsRcvd;
#ifdef LIBVNCSERVER_HAVE_LIBZ #ifdef LIBVNCSERVER_HAVE_LIBZ
/* zlib encoding -- necessary compression state info per client */ /* zlib encoding -- necessary compression state info per client */
@ -502,6 +536,7 @@ typedef struct _rfbClientRec {
rfbBool compStreamInitedLZO; rfbBool compStreamInitedLZO;
char *lzoWrkMem; char *lzoWrkMem;
rfbFileTransferData fileTransfer;
int lastKeyboardLedState; /* keep track of last value so we can send *change* events */ int lastKeyboardLedState; /* keep track of last value so we can send *change* events */
rfbBool enableSupportedMessages; /* client supports SupportedMessages encoding */ rfbBool enableSupportedMessages; /* client supports SupportedMessages encoding */
@ -584,6 +619,11 @@ extern char rfbEndianTest;
#define Swap24IfLE(l) (rfbEndianTest ? Swap24(l) : (l)) #define Swap24IfLE(l) (rfbEndianTest ? Swap24(l) : (l))
#define Swap32IfLE(l) (rfbEndianTest ? Swap32(l) : (l)) #define Swap32IfLE(l) (rfbEndianTest ? Swap32(l) : (l))
/* UltraVNC uses some windows structures unmodified, so the viewer expects LittleEndian Data */
#define Swap16IfBE(s) (rfbEndianTest ? (s) : Swap16(s))
#define Swap24IfBE(l) (rfbEndianTest ? (l) : Swap24(l))
#define Swap32IfBE(l) (rfbEndianTest ? (l) : Swap32(l))
/* sockets.c */ /* sockets.c */
extern int rfbMaxClientWait; extern int rfbMaxClientWait;
@ -634,6 +674,13 @@ extern rfbBool rfbSendNewFBSize(rfbClientPtr cl, int w, int h);
extern rfbBool rfbSendSetColourMapEntries(rfbClientPtr cl, int firstColour, int nColours); extern rfbBool rfbSendSetColourMapEntries(rfbClientPtr cl, int firstColour, int nColours);
extern void rfbSendBell(rfbScreenInfoPtr rfbScreen); extern void rfbSendBell(rfbScreenInfoPtr rfbScreen);
extern char *rfbProcessFileTransferReadBuffer(rfbClientPtr cl, uint32_t length);
extern rfbBool rfbSendFileTransferChunk(rfbClientPtr cl);
extern rfbBool rfbSendDirContent(rfbClientPtr cl, int length, char *buffer);
extern rfbBool rfbSendFileTransferMessage(rfbClientPtr cl, uint8_t contentType, uint8_t contentParam, uint32_t size, uint32_t length, char *buffer);
extern char *rfbProcessFileTransferReadBuffer(rfbClientPtr cl, uint32_t length);
extern rfbBool rfbProcessFileTransfer(rfbClientPtr cl, uint8_t contentType, uint8_t contentParam, uint32_t size, uint32_t length);
void rfbGotXCutText(rfbScreenInfoPtr rfbScreen, char *str, int len); void rfbGotXCutText(rfbScreenInfoPtr rfbScreen, char *str, int len);
/* translate.c */ /* translate.c */
@ -880,6 +927,38 @@ extern rfbBool rfbIsActive(rfbScreenInfoPtr screenInfo);
void rfbRegisterTightVNCFileTransferExtension(); void rfbRegisterTightVNCFileTransferExtension();
void rfbUnregisterTightVNCFileTransferExtension(); void rfbUnregisterTightVNCFileTransferExtension();
/* Statistics */
extern char *messageNameServer2Client(uint32_t type, char *buf, int len);
extern char *messageNameClient2Server(uint32_t type, char *buf, int len);
extern char *encodingName(uint32_t enc, char *buf, int len);
extern rfbStatList *rfbStatLookupEncoding(rfbClientPtr cl, uint32_t type);
extern rfbStatList *rfbStatLookupMessage(rfbClientPtr cl, uint32_t type);
/* Each call to rfbStatRecord* adds one to the rect count for that type */
extern void rfbStatRecordEncodingSent(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw);
extern void rfbStatRecordEncodingSentAdd(rfbClientPtr cl, uint32_t type, int byteCount); /* Specifically for tight encoding */
extern void rfbStatRecordEncodingRcvd(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw);
extern void rfbStatRecordMessageSent(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw);
extern void rfbStatRecordMessageRcvd(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw);
extern void rfbResetStats(rfbClientPtr cl);
extern void rfbPrintStats(rfbClientPtr cl);
extern int rfbStatGetSentBytes(rfbClientPtr cl);
extern int rfbStatGetSentBytesIfRaw(rfbClientPtr cl);
extern int rfbStatGetRcvdBytes(rfbClientPtr cl);
extern int rfbStatGetRcvdBytesIfRaw(rfbClientPtr cl);
extern int rfbStatGetMessageCountSent(rfbClientPtr cl, uint32_t type);
extern int rfbStatGetMessageCountRcvd(rfbClientPtr cl, uint32_t type);
extern int rfbStatGetEncodingCountSent(rfbClientPtr cl, uint32_t type);
extern int rfbStatGetEncodingCountRcvd(rfbClientPtr cl, uint32_t type);
/* Set which version you want to advertise 3.3, 3.6, 3.7 and 3.8 are currently supported*/
extern void rfbSetProtocolVersion(rfbScreenInfoPtr rfbScreen, int major_, int minor_);
#endif #endif
#if(defined __cplusplus) #if(defined __cplusplus)

21
rfb/rfbclient.h
Unescape View File

@ -96,6 +96,7 @@ typedef struct {
struct _rfbClient; struct _rfbClient;
typedef void (*HandleTextChatProc)(struct _rfbClient* client, int value, char *text);
typedef void (*HandleKeyboardLedStateProc)(struct _rfbClient* client, int value, int pad); typedef void (*HandleKeyboardLedStateProc)(struct _rfbClient* client, int value, int pad);
typedef rfbBool (*HandleCursorPosProc)(struct _rfbClient* client, int x, int y); typedef rfbBool (*HandleCursorPosProc)(struct _rfbClient* client, int x, int y);
typedef void (*SoftCursorLockAreaProc)(struct _rfbClient* client, int x, int y, int w, int h); typedef void (*SoftCursorLockAreaProc)(struct _rfbClient* client, int x, int y, int w, int h);
@ -210,6 +211,7 @@ typedef struct _rfbClient {
int canHandleNewFBSize; int canHandleNewFBSize;
/* hooks */ /* hooks */
HandleTextChatProc HandleTextChat;
HandleKeyboardLedStateProc HandleKeyboardLedState; HandleKeyboardLedStateProc HandleKeyboardLedState;
HandleCursorPosProc HandleCursorPos; HandleCursorPosProc HandleCursorPos;
SoftCursorLockAreaProc SoftCursorLockArea; SoftCursorLockAreaProc SoftCursorLockArea;
@ -219,6 +221,19 @@ typedef struct _rfbClient {
GetPasswordProc GetPassword; GetPasswordProc GetPassword;
MallocFrameBufferProc MallocFrameBuffer; MallocFrameBufferProc MallocFrameBuffer;
BellProc Bell; BellProc Bell;
/* Which messages are supported by the server
* This is a *guess* for most servers.
* (If we can even detect the type of server)
*
* If the server supports the "rfbEncodingSupportedMessages"
* then this will be updated when the encoding is received to
* accurately reflect the servers capabilities.
*/
rfbSupportedMessages supportedMessages;
/* negotiated protocol version */
int major, minor;
} rfbClient; } rfbClient;
/* cursor.c */ /* cursor.c */
@ -247,6 +262,12 @@ extern rfbBool SendKeyEvent(rfbClient* client,uint32_t key, rfbBool down);
extern rfbBool SendClientCutText(rfbClient* client,char *str, int len); extern rfbBool SendClientCutText(rfbClient* client,char *str, int len);
extern rfbBool HandleRFBServerMessage(rfbClient* client); extern rfbBool HandleRFBServerMessage(rfbClient* client);
extern rfbBool TextChatSend(rfbClient* client, char *text);
extern rfbBool TextChatOpen(rfbClient* client);
extern rfbBool TextChatClose(rfbClient* client);
extern rfbBool TextChatFinish(rfbClient* client);
extern rfbBool PermitServerInput(rfbClient* client, int enabled);
extern void PrintPixelFormat(rfbPixelFormat *format); extern void PrintPixelFormat(rfbPixelFormat *format);
/* client data */ /* client data */

22
rfb/rfbproto.h
Unescape View File

@ -218,8 +218,10 @@ typedef struct {
#define rfbProtocolVersionFormat "RFB %03d.%03d\n" #define rfbProtocolVersionFormat "RFB %03d.%03d\n"
#define rfbProtocolMajorVersion 3 #define rfbProtocolMajorVersion 3
#define rfbProtocolMinorVersion 7 #define rfbProtocolMinorVersion 6
#define rfbProtocolFallbackMinorVersion 3 /* UltraVNC Viewer examines rfbProtocolMinorVersion number (4, and 6)
* to identify if the server supports File Transfer
*/
typedef char rfbProtocolVersionMsg[13]; /* allow extra byte for null */ typedef char rfbProtocolVersionMsg[13]; /* allow extra byte for null */
@ -397,24 +399,18 @@ typedef struct {
#define rfbEncodingRRE 2 #define rfbEncodingRRE 2
#define rfbEncodingCoRRE 4 #define rfbEncodingCoRRE 4
#define rfbEncodingHextile 5 #define rfbEncodingHextile 5
#ifdef LIBVNCSERVER_HAVE_LIBZ
#define rfbEncodingZlib 6 #define rfbEncodingZlib 6
#define rfbEncodingTight 7 #define rfbEncodingTight 7
#define rfbEncodingZlibHex 8 #define rfbEncodingZlibHex 8
#endif
#define rfbEncodingUltra 9 #define rfbEncodingUltra 9
#ifdef LIBVNCSERVER_HAVE_LIBZ
#define rfbEncodingZRLE 16 #define rfbEncodingZRLE 16
#endif
/* Cache & XOR-Zlib - rdv@2002 */ /* Cache & XOR-Zlib - rdv@2002 */
#define rfbEncodingCache 0xFFFF0000 #define rfbEncodingCache 0xFFFF0000
#define rfbEncodingCacheEnable 0xFFFF0001 #define rfbEncodingCacheEnable 0xFFFF0001
#ifdef LIBVNCSERVER_HAVE_LIBZ
#define rfbEncodingXOR_Zlib 0xFFFF0002 #define rfbEncodingXOR_Zlib 0xFFFF0002
#define rfbEncodingXORMonoColor_Zlib 0xFFFF0003 #define rfbEncodingXORMonoColor_Zlib 0xFFFF0003
#define rfbEncodingXORMultiColor_Zlib 0xFFFF0004 #define rfbEncodingXORMultiColor_Zlib 0xFFFF0004
#endif
#define rfbEncodingSolidColor 0xFFFF0005 #define rfbEncodingSolidColor 0xFFFF0005
#define rfbEncodingXOREnable 0xFFFF0006 #define rfbEncodingXOREnable 0xFFFF0006
#define rfbEncodingCacheZip 0xFFFF0007 #define rfbEncodingCacheZip 0xFFFF0007
@ -649,11 +645,11 @@ typedef struct {
#define rfbHextileExtractW(byte) (((byte) >> 4) + 1) #define rfbHextileExtractW(byte) (((byte) >> 4) + 1)
#define rfbHextileExtractH(byte) (((byte) & 0xf) + 1) #define rfbHextileExtractH(byte) (((byte) & 0xf) + 1)
#ifdef LIBVNCSERVER_HAVE_LIBZ
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* zlib - zlib compressed Encoding. We have an rfbZlibHeader structure * zlib - zlib compressed Encoding. We have an rfbZlibHeader structure
* giving the number of bytes following. Finally the data follows is * giving the number of bytes following. Finally the data follows is
* zlib compressed version of the raw pixel data as negotiated. * zlib compressed version of the raw pixel data as negotiated.
* (NOTE: also used by Ultra Encoding)
*/ */
typedef struct { typedef struct {
@ -662,6 +658,7 @@ typedef struct {
#define sz_rfbZlibHeader 4 #define sz_rfbZlibHeader 4
#ifdef LIBVNCSERVER_HAVE_LIBZ
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* Tight Encoding. * Tight Encoding.
@ -935,9 +932,10 @@ typedef struct {
typedef struct _rfbFileTransferMsg { typedef struct _rfbFileTransferMsg {
uint8_t type; /* always rfbFileTransfer */ uint8_t type; /* always rfbFileTransfer */
uint8_t contentType; /* See defines below */ uint8_t contentType; /* See defines below */
uint16_t contentParam;/* Other possible content classification (Dir or File name, etc..) */ uint8_t contentParam;/* Other possible content classification (Dir or File name, etc..) */
uint32_t size; /* FileSize or packet index or error or other */ uint8_t pad; /* It appears that UltraVNC *forgot* to Swap16IfLE(contentParam) */
/* uint32_t sizeH; Additional 32Bits params to handle big values. Only for V2 (we want backward compatibility between all V1 versions) */ uint32_t size; /* FileSize or packet index or error or other */
/* uint32_t sizeH; Additional 32Bits params to handle big values. Only for V2 (we want backward compatibility between all V1 versions) */
uint32_t length; uint32_t length;
/* followed by data char text[length] */ /* followed by data char text[length] */
} rfbFileTransferMsg; } rfbFileTransferMsg;

11
x11vnc/rates.c
Unescape View File

@ -350,11 +350,8 @@ db = 0;
} }
nclients++; nclients++;
cbs = 0; cbs = rfbStatGetSentBytes(cl);
for (i=0; i<MAX_ENCODINGS; i++) { rbs = rfbStatGetSentBytesIfRaw(cl);
cbs += cl->bytesSent[i];
}
rbs = cl->rawBytesEquivalent;
if (init) { if (init) {
@ -435,7 +432,7 @@ if (db) fprintf(stderr, "%d client num rects req: %d mod: %d cbs: %d "
if (db) fprintf(stderr, "dt2 calc: num rects req: %d/%d mod: %d/%d " if (db) fprintf(stderr, "dt2 calc: num rects req: %d/%d mod: %d/%d "
"fbu-sent: %d dt: %.4f dt2: %.4f tm: %.4f\n", "fbu-sent: %d dt: %.4f dt2: %.4f tm: %.4f\n",
req0, req1, mod0, mod1, cl->framebufferUpdateMessagesSent, dt, dt2, tm); req0, req1, mod0, mod1, rfbStatGetMessageCountSent(cl, rfbFramebufferUpdate), dt, dt2, tm);
if (req1 != 0 && mod1 == 0) { if (req1 != 0 && mod1 == 0) {
got_t2 = 1; got_t2 = 1;
break; break;
@ -502,7 +499,7 @@ if (db) fprintf(stderr, "dt2 calc: num rects req: %d/%d mod: %d/%d "
if (db) fprintf(stderr, "dt3 calc: num rects req: %d/%d mod: %d/%d " if (db) fprintf(stderr, "dt3 calc: num rects req: %d/%d mod: %d/%d "
"fbu-sent: %d dt: %.4f dt3: %.4f tm: %.4f\n", "fbu-sent: %d dt: %.4f dt3: %.4f tm: %.4f\n",
req0, req1, mod0, mod1, cl->framebufferUpdateMessagesSent, dt, dt3, tm); req0, req1, mod0, mod1, rfbStatGetMessageCountSent(cl, rfbFramebufferUpdate), dt, dt3, tm);
if (req1 != 0 && mod1 == 0) { if (req1 != 0 && mod1 == 0) {
dts[got_t3++] = dt3; dts[got_t3++] = dt3;

2
x11vnc/userinput.c
Unescape View File

@ -4082,7 +4082,7 @@ int fb_update_sent(int *count) {
i = rfbGetClientIterator(screen); i = rfbGetClientIterator(screen);
while( (cl = rfbClientIteratorNext(i)) ) { while( (cl = rfbClientIteratorNext(i)) ) {
sent += cl->framebufferUpdateMessagesSent; sent += rfbStatGetMessageCountSent(cl, rfbFramebufferUpdate);
} }
rfbReleaseClientIterator(i); rfbReleaseClientIterator(i);
if (sent != last_count) { if (sent != last_count) {

Write Preview
Loading…
Cancel
Save