1 #ifndef RFB_H 2 #define RFB_H 3 /** 4 * @defgroup libvncserver_api LibVNCServer API Reference 5 * @{ 6 */ 7 8 /** 9 * @file rfb.h 10 */ 11 12 /* 13 * Copyright (C) 2005 Rohit Kumar <rokumar (at) novell.com>, 14 * Johannes E. Schindelin <johannes.schindelin (at) gmx.de> 15 * Copyright (C) 2002 RealVNC Ltd. 16 * OSXvnc Copyright (C) 2001 Dan McGuirk <mcguirk (at) incompleteness.net>. 17 * Original Xvnc code Copyright (C) 1999 AT&T Laboratories Cambridge. 18 * All Rights Reserved. 19 * 20 * This is free software; you can redistribute it and/or modify 21 * it under the terms of the GNU General Public License as published by 22 * the Free Software Foundation; either version 2 of the License, or 23 * (at your option) any later version. 24 * 25 * This software is distributed in the hope that it will be useful, 26 * but WITHOUT ANY WARRANTY; without even the implied warranty of 27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 28 * GNU General Public License for more details. 29 * 30 * You should have received a copy of the GNU General Public License 31 * along with this software; if not, write to the Free Software 32 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 33 * USA. 34 */ 35 36 #if(defined __cplusplus) 37 extern "C" 38 { 39 #endif 40 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <rfb/rfbproto.h> 45 46 #if defined(ANDROID) || defined(LIBVNCSERVER_HAVE_ANDROID) 47 #include <arpa/inet.h> 48 #include <sys/select.h> 49 #endif 50 51 #ifdef LIBVNCSERVER_HAVE_SYS_TYPES_H 52 #include <sys/types.h> 53 #endif 54 55 #ifdef WIN32 56 #undef SOCKET 57 #include <winsock2.h> 58 #ifdef LIBVNCSERVER_HAVE_WS2TCPIP_H 59 #undef socklen_t 60 #include <ws2tcpip.h> 61 #endif 62 #endif 63 64 #ifdef LIBVNCSERVER_HAVE_LIBPTHREAD 65 #include <pthread.h> 66 #if 0 /* debugging */ 67 #define LOCK(mutex) (rfbLog("%s:%d LOCK(%s,0x%x)\n",__FILE__,__LINE__,#mutex,&(mutex)), pthread_mutex_lock(&(mutex))) 68 #define UNLOCK(mutex) (rfbLog("%s:%d UNLOCK(%s,0x%x)\n",__FILE__,__LINE__,#mutex,&(mutex)), pthread_mutex_unlock(&(mutex))) 69 #define MUTEX(mutex) pthread_mutex_t (mutex) 70 #define INIT_MUTEX(mutex) (rfbLog("%s:%d INIT_MUTEX(%s,0x%x)\n",__FILE__,__LINE__,#mutex,&(mutex)), pthread_mutex_init(&(mutex),NULL)) 71 #define TINI_MUTEX(mutex) (rfbLog("%s:%d TINI_MUTEX(%s)\n",__FILE__,__LINE__,#mutex), pthread_mutex_destroy(&(mutex))) 72 #define TSIGNAL(cond) (rfbLog("%s:%d TSIGNAL(%s)\n",__FILE__,__LINE__,#cond), pthread_cond_signal(&(cond))) 73 #define WAIT(cond,mutex) (rfbLog("%s:%d WAIT(%s,%s)\n",__FILE__,__LINE__,#cond,#mutex), pthread_cond_wait(&(cond),&(mutex))) 74 #define COND(cond) pthread_cond_t (cond) 75 #define INIT_COND(cond) (rfbLog("%s:%d INIT_COND(%s)\n",__FILE__,__LINE__,#cond), pthread_cond_init(&(cond),NULL)) 76 #define TINI_COND(cond) (rfbLog("%s:%d TINI_COND(%s)\n",__FILE__,__LINE__,#cond), pthread_cond_destroy(&(cond))) 77 #define IF_PTHREADS(x) x 78 #else 79 #if !NONETWORK 80 #define LOCK(mutex) pthread_mutex_lock(&(mutex)); 81 #define UNLOCK(mutex) pthread_mutex_unlock(&(mutex)); 82 #endif 83 #define MUTEX(mutex) pthread_mutex_t (mutex) 84 #define INIT_MUTEX(mutex) pthread_mutex_init(&(mutex),NULL) 85 #define TINI_MUTEX(mutex) pthread_mutex_destroy(&(mutex)) 86 #define TSIGNAL(cond) pthread_cond_signal(&(cond)) 87 #define WAIT(cond,mutex) pthread_cond_wait(&(cond),&(mutex)) 88 #define COND(cond) pthread_cond_t (cond) 89 #define INIT_COND(cond) pthread_cond_init(&(cond),NULL) 90 #define TINI_COND(cond) pthread_cond_destroy(&(cond)) 91 #define IF_PTHREADS(x) x 92 #endif 93 #else 94 #define LOCK(mutex) 95 #define UNLOCK(mutex) 96 #define MUTEX(mutex) 97 #define INIT_MUTEX(mutex) 98 #define TINI_MUTEX(mutex) 99 #define TSIGNAL(cond) 100 #define WAIT(cond,mutex) this_is_unsupported 101 #define COND(cond) 102 #define INIT_COND(cond) 103 #define TINI_COND(cond) 104 #define IF_PTHREADS(x) 105 #endif 106 107 /* end of stuff for autoconf */ 108 109 /* if you use pthreads, but don't define LIBVNCSERVER_HAVE_LIBPTHREAD, the structs 110 get all mixed up. So this gives a linker error reminding you to compile 111 the library and your application (at least the parts including rfb.h) 112 with the same support for pthreads. */ 113 #ifdef LIBVNCSERVER_HAVE_LIBPTHREAD 114 #ifdef LIBVNCSERVER_HAVE_LIBZ 115 #define rfbInitServer rfbInitServerWithPthreadsAndZRLE 116 #else 117 #define rfbInitServer rfbInitServerWithPthreadsButWithoutZRLE 118 #endif 119 #else 120 #ifdef LIBVNCSERVER_HAVE_LIBZ 121 #define rfbInitServer rfbInitServerWithoutPthreadsButWithZRLE 122 #else 123 #define rfbInitServer rfbInitServerWithoutPthreadsAndZRLE 124 #endif 125 #endif 126 127 struct _rfbClientRec; 128 struct _rfbScreenInfo; 129 struct rfbCursor; 130 131 enum rfbNewClientAction { 132 RFB_CLIENT_ACCEPT, 133 RFB_CLIENT_ON_HOLD, 134 RFB_CLIENT_REFUSE 135 }; 136 137 enum rfbSocketState { 138 RFB_SOCKET_INIT, 139 RFB_SOCKET_READY, 140 RFB_SOCKET_SHUTDOWN 141 }; 142 143 typedef void (*rfbKbdAddEventProcPtr) (rfbBool down, rfbKeySym keySym, struct _rfbClientRec* cl); 144 typedef void (*rfbKbdReleaseAllKeysProcPtr) (struct _rfbClientRec* cl); 145 typedef void (*rfbPtrAddEventProcPtr) (int buttonMask, int x, int y, struct _rfbClientRec* cl); 146 typedef void (*rfbSetXCutTextProcPtr) (char* str,int len, struct _rfbClientRec* cl); 147 typedef struct rfbCursor* (*rfbGetCursorProcPtr) (struct _rfbClientRec* pScreen); 148 typedef rfbBool (*rfbSetTranslateFunctionProcPtr)(struct _rfbClientRec* cl); 149 typedef rfbBool (*rfbPasswordCheckProcPtr)(struct _rfbClientRec* cl,const char* encryptedPassWord,int len); 150 typedef enum rfbNewClientAction (*rfbNewClientHookPtr)(struct _rfbClientRec* cl); 151 typedef void (*rfbDisplayHookPtr)(struct _rfbClientRec* cl); 152 typedef void (*rfbDisplayFinishedHookPtr)(struct _rfbClientRec* cl, int result); 153 /** support the capability to view the caps/num/scroll states of the X server */ 154 typedef int (*rfbGetKeyboardLedStateHookPtr)(struct _rfbScreenInfo* screen); 155 typedef rfbBool (*rfbXvpHookPtr)(struct _rfbClientRec* cl, uint8_t, uint8_t); 156 /** 157 * If x==1 and y==1 then set the whole display 158 * else find the window underneath x and y and set the framebuffer to the dimensions 159 * of that window 160 */ 161 typedef void (*rfbSetSingleWindowProcPtr) (struct _rfbClientRec* cl, int x, int y); 162 /** 163 * Status determines if the X11 server permits input from the local user 164 * status==0 or 1 165 */ 166 typedef void (*rfbSetServerInputProcPtr) (struct _rfbClientRec* cl, int status); 167 /** 168 * Permit the server to allow or deny filetransfers. This is defaulted to deny 169 * It is called when a client initiates a connection to determine if it is permitted. 170 */ 171 typedef int (*rfbFileTransferPermitted) (struct _rfbClientRec* cl); 172 /** Handle the textchat messages */ 173 typedef void (*rfbSetTextChat) (struct _rfbClientRec* cl, int length, char *string); 174 175 typedef struct { 176 uint32_t count; 177 rfbBool is16; /**< is the data format short? */ 178 union { 179 uint8_t* bytes; 180 uint16_t* shorts; 181 } data; /**< there have to be count*3 entries */ 182 } rfbColourMap; 183 184 /** 185 * Security handling (RFB protocol version 3.7) 186 */ 187 188 typedef struct _rfbSecurity { 189 uint8_t type; 190 void (*handler)(struct _rfbClientRec* cl); 191 struct _rfbSecurity* next; 192 } rfbSecurityHandler; 193 194 /** 195 * Protocol extension handling. 196 */ 197 198 typedef struct _rfbProtocolExtension { 199 /** returns FALSE if extension should be deactivated for client. 200 if newClient == NULL, it is always deactivated. */ 201 rfbBool (*newClient)(struct _rfbClientRec* client, void** data); 202 /** returns FALSE if extension should be deactivated for client. 203 if init == NULL, it stays activated. */ 204 rfbBool (*init)(struct _rfbClientRec* client, void* data); 205 /** if pseudoEncodings is not NULL, it contains a 0 terminated 206 list of the pseudo encodings handled by this extension. */ 207 int *pseudoEncodings; 208 /** returns TRUE if that pseudo encoding is handled by the extension. 209 encodingNumber==0 means "reset encodings". */ 210 rfbBool (*enablePseudoEncoding)(struct _rfbClientRec* client, 211 void** data, int encodingNumber); 212 /** returns TRUE if message was handled */ 213 rfbBool (*handleMessage)(struct _rfbClientRec* client, 214 void* data, 215 const rfbClientToServerMsg* message); 216 void (*close)(struct _rfbClientRec* client, void* data); 217 void (*usage)(void); 218 /** processArguments returns the number of handled arguments */ 219 int (*processArgument)(int argc, char *argv[]); 220 struct _rfbProtocolExtension* next; 221 } rfbProtocolExtension; 222 223 typedef struct _rfbExtensionData { 224 rfbProtocolExtension* extension; 225 void* data; 226 struct _rfbExtensionData* next; 227 } rfbExtensionData; 228 229 /** 230 * Per-screen (framebuffer) structure. There can be as many as you wish, 231 * each serving different clients. However, you have to call 232 * rfbProcessEvents for each of these. 233 */ 234 235 typedef struct _rfbScreenInfo 236 { 237 /** this structure has children that are scaled versions of this screen */ 238 struct _rfbScreenInfo *scaledScreenNext; 239 int scaledScreenRefCount; 240 241 int width; 242 int paddedWidthInBytes; 243 int height; 244 int depth; 245 int bitsPerPixel; 246 int sizeInBytes; 247 248 rfbPixel blackPixel; 249 rfbPixel whitePixel; 250 251 /** 252 * some screen specific data can be put into a struct where screenData 253 * points to. You need this if you have more than one screen at the 254 * same time while using the same functions. 255 */ 256 void* screenData; 257 258 /* additions by libvncserver */ 259 260 rfbPixelFormat serverFormat; 261 rfbColourMap colourMap; /**< set this if rfbServerFormat.trueColour==FALSE */ 262 const char* desktopName; 263 char thisHost[255]; 264 265 rfbBool autoPort; 266 int port; 267 SOCKET listenSock; 268 int maxSock; 269 int maxFd; 270 #ifdef WIN32 271 struct fd_set allFds; 272 #else 273 fd_set allFds; 274 #endif 275 276 enum rfbSocketState socketState; 277 SOCKET inetdSock; 278 rfbBool inetdInitDone; 279 280 int udpPort; 281 SOCKET udpSock; 282 struct _rfbClientRec* udpClient; 283 rfbBool udpSockConnected; 284 struct sockaddr_in udpRemoteAddr; 285 286 int maxClientWait; 287 288 /* http stuff */ 289 rfbBool httpInitDone; 290 rfbBool httpEnableProxyConnect; 291 int httpPort; 292 char* httpDir; 293 SOCKET httpListenSock; 294 SOCKET httpSock; 295 296 rfbPasswordCheckProcPtr passwordCheck; 297 void* authPasswdData; 298 /** If rfbAuthPasswdData is given a list, this is the first 299 view only password. */ 300 int authPasswdFirstViewOnly; 301 302 /** send only this many rectangles in one update */ 303 int maxRectsPerUpdate; 304 /** this is the amount of milliseconds to wait at least before sending 305 * an update. */ 306 int deferUpdateTime; 307 #ifdef TODELETE 308 char* screen; 309 #endif 310 rfbBool alwaysShared; 311 rfbBool neverShared; 312 rfbBool dontDisconnect; 313 struct _rfbClientRec* clientHead; 314 struct _rfbClientRec* pointerClient; /**< "Mutex" for pointer events */ 315 316 317 /* cursor */ 318 int cursorX, cursorY,underCursorBufferLen; 319 char* underCursorBuffer; 320 rfbBool dontConvertRichCursorToXCursor; 321 struct rfbCursor* cursor; 322 323 /** 324 * the frameBuffer has to be supplied by the serving process. 325 * The buffer will not be freed by 326 */ 327 char* frameBuffer; 328 rfbKbdAddEventProcPtr kbdAddEvent; 329 rfbKbdReleaseAllKeysProcPtr kbdReleaseAllKeys; 330 rfbPtrAddEventProcPtr ptrAddEvent; 331 rfbSetXCutTextProcPtr setXCutText; 332 rfbGetCursorProcPtr getCursorPtr; 333 rfbSetTranslateFunctionProcPtr setTranslateFunction; 334 rfbSetSingleWindowProcPtr setSingleWindow; 335 rfbSetServerInputProcPtr setServerInput; 336 rfbFileTransferPermitted getFileTransferPermission; 337 rfbSetTextChat setTextChat; 338 339 /** newClientHook is called just after a new client is created */ 340 rfbNewClientHookPtr newClientHook; 341 /** displayHook is called just before a frame buffer update */ 342 rfbDisplayHookPtr displayHook; 343 344 /** These hooks are called to pass keyboard state back to the client */ 345 rfbGetKeyboardLedStateHookPtr getKeyboardLedStateHook; 346 347 #ifdef LIBVNCSERVER_HAVE_LIBPTHREAD 348 MUTEX(cursorMutex); 349 rfbBool backgroundLoop; 350 #endif 351 352 /** if TRUE, an ignoring signal handler is installed for SIGPIPE */ 353 rfbBool ignoreSIGPIPE; 354 355 /** if not zero, only a slice of this height is processed every time 356 * an update should be sent. This should make working on a slow 357 * link more interactive. */ 358 int progressiveSliceHeight; 359 360 in_addr_t listenInterface; 361 int deferPtrUpdateTime; 362 363 /** handle as many input events as possible (default off) */ 364 rfbBool handleEventsEagerly; 365 366 /** rfbEncodingServerIdentity */ 367 char *versionString; 368 369 /** What does the server tell the new clients which version it supports */ 370 int protocolMajorVersion; 371 int protocolMinorVersion; 372 373 /** command line authorization of file transfers */ 374 rfbBool permitFileTransfer; 375 376 /** displayFinishedHook is called just after a frame buffer update */ 377 rfbDisplayFinishedHookPtr displayFinishedHook; 378 /** xvpHook is called to handle an xvp client message */ 379 rfbXvpHookPtr xvpHook; 380 #ifdef LIBVNCSERVER_WITH_WEBSOCKETS 381 char *sslkeyfile; 382 char *sslcertfile; 383 #endif 384 int ipv6port; /**< The port to listen on when using IPv6. */ 385 char* listen6Interface; 386 /* We have an additional IPv6 listen socket since there are systems that 387 don't support dual binding sockets under *any* circumstances, for 388 instance OpenBSD */ 389 SOCKET listen6Sock; 390 int http6Port; 391 SOCKET httpListen6Sock; 392 } rfbScreenInfo, *rfbScreenInfoPtr; 393 394 395 /** 396 * rfbTranslateFnType is the type of translation functions. 397 */ 398 399 typedef void (*rfbTranslateFnType)(char *table, rfbPixelFormat *in, 400 rfbPixelFormat *out, 401 char *iptr, char *optr, 402 int bytesBetweenInputLines, 403 int width, int height); 404 405 406 /* region stuff */ 407 408 struct sraRegion; 409 typedef struct sraRegion* sraRegionPtr; 410 411 /* 412 * Per-client structure. 413 */ 414 415 typedef void (*ClientGoneHookPtr)(struct _rfbClientRec* cl); 416 417 typedef struct _rfbFileTransferData { 418 int fd; 419 int compressionEnabled; 420 int fileSize; 421 int numPackets; 422 int receiving; 423 int sending; 424 } rfbFileTransferData; 425 426 427 typedef struct _rfbStatList { 428 uint32_t type; 429 uint32_t sentCount; 430 uint32_t bytesSent; 431 uint32_t bytesSentIfRaw; 432 uint32_t rcvdCount; 433 uint32_t bytesRcvd; 434 uint32_t bytesRcvdIfRaw; 435 struct _rfbStatList *Next; 436 } rfbStatList; 437 438 typedef struct _rfbSslCtx rfbSslCtx; 439 typedef struct _wsCtx wsCtx; 440 441 typedef struct _rfbClientRec { 442 443 /** back pointer to the screen */ 444 rfbScreenInfoPtr screen; 445 446 /** points to a scaled version of the screen buffer in cl->scaledScreenList */ 447 rfbScreenInfoPtr scaledScreen; 448 /** how did the client tell us it wanted the screen changed? Ultra style or palm style? */ 449 rfbBool PalmVNC; 450 451 452 /** private data. You should put any application client specific data 453 * into a struct and let clientData point to it. Don't forget to 454 * free the struct via clientGoneHook! 455 * 456 * This is useful if the IO functions have to behave client specific. 457 */ 458 void* clientData; 459 ClientGoneHookPtr clientGoneHook; 460 461 SOCKET sock; 462 char *host; 463 464 /* RFB protocol minor version number */ 465 int protocolMajorVersion; 466 int protocolMinorVersion; 467 468 #ifdef LIBVNCSERVER_HAVE_LIBPTHREAD 469 pthread_t client_thread; 470 #endif 471 472 /* Note that the RFB_INITIALISATION_SHARED state is provided to support 473 clients that under some circumstances do not send a ClientInit message. 474 In particular the Mac OS X built-in VNC client (with protocolMinorVersion 475 == 889) is one of those. However, it only requires this support under 476 special circumstances that can only be determined during the initial 477 authentication. If the right conditions are met this state will be 478 set (see the auth.c file) when rfbProcessClientInitMessage is called. 479 480 If the state is RFB_INITIALISATION_SHARED we should not expect to recieve 481 any ClientInit message, but instead should proceed to the next stage 482 of initialisation as though an implicit ClientInit message was received 483 with a shared-flag of true. (There is currently no corresponding 484 RFB_INITIALISATION_NOTSHARED state to represent an implicit ClientInit 485 message with a shared-flag of false because no known existing client 486 requires such support at this time.) 487 488 Note that software using LibVNCServer to provide a VNC server will only 489 ever have a chance to see the state field set to 490 RFB_INITIALISATION_SHARED if the software is multi-threaded and manages 491 to examine the state field during the extremely brief window after the 492 'None' authentication type selection has been received from the built-in 493 OS X VNC client and before the rfbProcessClientInitMessage function is 494 called -- control cannot return to the caller during this brief window 495 while the state field is set to RFB_INITIALISATION_SHARED. */ 496 497 /** Possible client states: */ 498 enum { 499 RFB_PROTOCOL_VERSION, /**< establishing protocol version */ 500 RFB_SECURITY_TYPE, /**< negotiating security (RFB v.3.7) */ 501 RFB_AUTHENTICATION, /**< authenticating */ 502 RFB_INITIALISATION, /**< sending initialisation messages */ 503 RFB_NORMAL, /**< normal protocol messages */ 504 505 /* Ephemeral internal-use states that will never be seen by software 506 * using LibVNCServer to provide services: */ 507 508 RFB_INITIALISATION_SHARED /**< sending initialisation messages with implicit shared-flag already true */ 509 } state; 510 511 rfbBool reverseConnection; 512 rfbBool onHold; 513 rfbBool readyForSetColourMapEntries; 514 rfbBool useCopyRect; 515 int preferredEncoding; 516 int correMaxWidth, correMaxHeight; 517 518 rfbBool viewOnly; 519 520 /* The following member is only used during VNC authentication */ 521 uint8_t authChallenge[CHALLENGESIZE]; 522 523 /* The following members represent the update needed to get the client's 524 framebuffer from its present state to the current state of our 525 framebuffer. 526 527 If the client does not accept CopyRect encoding then the update is 528 simply represented as the region of the screen which has been modified 529 (modifiedRegion). 530 531 If the client does accept CopyRect encoding, then the update consists of 532 two parts. First we have a single copy from one region of the screen to 533 another (the destination of the copy is copyRegion), and second we have 534 the region of the screen which has been modified in some other way 535 (modifiedRegion). 536 537 Although the copy is of a single region, this region may have many 538 rectangles. When sending an update, the copyRegion is always sent 539 before the modifiedRegion. This is because the modifiedRegion may 540 overlap parts of the screen which are in the source of the copy. 541 542 In fact during normal processing, the modifiedRegion may even overlap 543 the destination copyRegion. Just before an update is sent we remove 544 from the copyRegion anything in the modifiedRegion. */ 545 546 sraRegionPtr copyRegion; /**< the destination region of the copy */ 547 int copyDX, copyDY; /**< the translation by which the copy happens */ 548 549 sraRegionPtr modifiedRegion; 550 551 /** As part of the FramebufferUpdateRequest, a client can express interest 552 in a subrectangle of the whole framebuffer. This is stored in the 553 requestedRegion member. In the normal case this is the whole 554 framebuffer if the client is ready, empty if it's not. */ 555 556 sraRegionPtr requestedRegion; 557 558 /** The following member represents the state of the "deferred update" timer 559 - when the framebuffer is modified and the client is ready, in most 560 cases it is more efficient to defer sending the update by a few 561 milliseconds so that several changes to the framebuffer can be combined 562 into a single update. */ 563 564 struct timeval startDeferring; 565 struct timeval startPtrDeferring; 566 int lastPtrX; 567 int lastPtrY; 568 int lastPtrButtons; 569 570 /** translateFn points to the translation function which is used to copy 571 and translate a rectangle from the framebuffer to an output buffer. */ 572 573 rfbTranslateFnType translateFn; 574 char *translateLookupTable; 575 rfbPixelFormat format; 576 577 /** 578 * UPDATE_BUF_SIZE must be big enough to send at least one whole line of the 579 * framebuffer. So for a max screen width of say 2K with 32-bit pixels this 580 * means 8K minimum. 581 */ 582 583 #define UPDATE_BUF_SIZE 30000 584 585 char updateBuf[UPDATE_BUF_SIZE]; 586 int ublen; 587 588 /* statistics */ 589 struct _rfbStatList *statEncList; 590 struct _rfbStatList *statMsgList; 591 int rawBytesEquivalent; 592 int bytesSent; 593 594 #ifdef LIBVNCSERVER_HAVE_LIBZ 595 /* zlib encoding -- necessary compression state info per client */ 596 597 struct z_stream_s compStream; 598 rfbBool compStreamInited; 599 uint32_t zlibCompressLevel; 600 #endif 601 #if defined(LIBVNCSERVER_HAVE_LIBZ) || defined(LIBVNCSERVER_HAVE_LIBPNG) 602 /** the quality level is also used by ZYWRLE and TightPng */ 603 int tightQualityLevel; 604 605 #ifdef LIBVNCSERVER_HAVE_LIBJPEG 606 /* tight encoding -- preserve zlib streams' state for each client */ 607 z_stream zsStruct[4]; 608 rfbBool zsActive[4]; 609 int zsLevel[4]; 610 int tightCompressLevel; 611 #endif 612 #endif 613 614 /* Ultra Encoding support */ 615 rfbBool compStreamInitedLZO; 616 char *lzoWrkMem; 617 618 rfbFileTransferData fileTransfer; 619 620 int lastKeyboardLedState; /**< keep track of last value so we can send *change* events */ 621 rfbBool enableSupportedMessages; /**< client supports SupportedMessages encoding */ 622 rfbBool enableSupportedEncodings; /**< client supports SupportedEncodings encoding */ 623 rfbBool enableServerIdentity; /**< client supports ServerIdentity encoding */ 624 rfbBool enableKeyboardLedState; /**< client supports KeyboardState encoding */ 625 rfbBool enableLastRectEncoding; /**< client supports LastRect encoding */ 626 rfbBool enableCursorShapeUpdates; /**< client supports cursor shape updates */ 627 rfbBool enableCursorPosUpdates; /**< client supports cursor position updates */ 628 rfbBool useRichCursorEncoding; /**< rfbEncodingRichCursor is preferred */ 629 rfbBool cursorWasChanged; /**< cursor shape update should be sent */ 630 rfbBool cursorWasMoved; /**< cursor position update should be sent */ 631 int cursorX,cursorY; /**< the coordinates of the cursor, 632 if enableCursorShapeUpdates = FALSE */ 633 634 rfbBool useNewFBSize; /**< client supports NewFBSize encoding */ 635 rfbBool newFBSizePending; /**< framebuffer size was changed */ 636 637 struct _rfbClientRec *prev; 638 struct _rfbClientRec *next; 639 640 #ifdef LIBVNCSERVER_HAVE_LIBPTHREAD 641 /** whenever a client is referenced, the refCount has to be incremented 642 and afterwards decremented, so that the client is not cleaned up 643 while being referenced. 644 Use the functions rfbIncrClientRef(cl) and rfbDecrClientRef(cl); 645 */ 646 int refCount; 647 MUTEX(refCountMutex); 648 COND(deleteCond); 649 650 MUTEX(outputMutex); 651 MUTEX(updateMutex); 652 COND(updateCond); 653 #endif 654 655 #ifdef LIBVNCSERVER_HAVE_LIBZ 656 void* zrleData; 657 int zywrleLevel; 658 int zywrleBuf[rfbZRLETileWidth * rfbZRLETileHeight]; 659 #endif 660 661 /** if progressive updating is on, this variable holds the current 662 * y coordinate of the progressive slice. */ 663 int progressiveSliceY; 664 665 rfbExtensionData* extensions; 666 667 /** for threaded zrle */ 668 char *zrleBeforeBuf; 669 void *paletteHelper; 670 671 /** for thread safety for rfbSendFBUpdate() */ 672 #ifdef LIBVNCSERVER_HAVE_LIBPTHREAD 673 #define LIBVNCSERVER_SEND_MUTEX 674 MUTEX(sendMutex); 675 #endif 676 677 /* buffers to hold pixel data before and after encoding. 678 per-client for thread safety */ 679 char *beforeEncBuf; 680 int beforeEncBufSize; 681 char *afterEncBuf; 682 int afterEncBufSize; 683 int afterEncBufLen; 684 #if defined(LIBVNCSERVER_HAVE_LIBZ) || defined(LIBVNCSERVER_HAVE_LIBPNG) 685 uint32_t tightEncoding; /* rfbEncodingTight or rfbEncodingTightPng */ 686 #ifdef LIBVNCSERVER_HAVE_LIBJPEG 687 /* TurboVNC Encoding support (extends TightVNC) */ 688 int turboSubsampLevel; 689 int turboQualityLevel; /* 1-100 scale */ 690 #endif 691 #endif 692 693 #ifdef LIBVNCSERVER_WITH_WEBSOCKETS 694 rfbSslCtx *sslctx; 695 wsCtx *wsctx; 696 char *wspath; /* Requests path component */ 697 #endif 698 } rfbClientRec, *rfbClientPtr; 699 700 /** 701 * This macro is used to test whether there is a framebuffer update needing to 702 * be sent to the client. 703 */ 704 705 #define FB_UPDATE_PENDING(cl) \ 706 (((cl)->enableCursorShapeUpdates && (cl)->cursorWasChanged) || \ 707 (((cl)->enableCursorShapeUpdates == FALSE && \ 708 ((cl)->cursorX != (cl)->screen->cursorX || \ 709 (cl)->cursorY != (cl)->screen->cursorY))) || \ 710 ((cl)->useNewFBSize && (cl)->newFBSizePending) || \ 711 ((cl)->enableCursorPosUpdates && (cl)->cursorWasMoved) || \ 712 !sraRgnEmpty((cl)->copyRegion) || !sraRgnEmpty((cl)->modifiedRegion)) 713 714 /* 715 * Macros for endian swapping. 716 */ 717 718 #define Swap16(s) ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) 719 720 #define Swap24(l) ((((l) & 0xff) << 16) | (((l) >> 16) & 0xff) | \ 721 (((l) & 0x00ff00))) 722 723 #define Swap32(l) (((l) >> 24) | \ 724 (((l) & 0x00ff0000) >> 8) | \ 725 (((l) & 0x0000ff00) << 8) | \ 726 ((l) << 24)) 727 728 729 extern char rfbEndianTest; 730 731 #define Swap16IfLE(s) (rfbEndianTest ? Swap16(s) : (s)) 732 #define Swap24IfLE(l) (rfbEndianTest ? Swap24(l) : (l)) 733 #define Swap32IfLE(l) (rfbEndianTest ? Swap32(l) : (l)) 734 735 /* UltraVNC uses some windows structures unmodified, so the viewer expects LittleEndian Data */ 736 #define Swap16IfBE(s) (rfbEndianTest ? (s) : Swap16(s)) 737 #define Swap24IfBE(l) (rfbEndianTest ? (l) : Swap24(l)) 738 #define Swap32IfBE(l) (rfbEndianTest ? (l) : Swap32(l)) 739 740 /* sockets.c */ 741 742 extern int rfbMaxClientWait; 743 744 extern void rfbInitSockets(rfbScreenInfoPtr rfbScreen); 745 extern void rfbShutdownSockets(rfbScreenInfoPtr rfbScreen); 746 extern void rfbDisconnectUDPSock(rfbScreenInfoPtr rfbScreen); 747 extern void rfbCloseClient(rfbClientPtr cl); 748 extern int rfbReadExact(rfbClientPtr cl, char *buf, int len); 749 extern int rfbReadExactTimeout(rfbClientPtr cl, char *buf, int len,int timeout); 750 extern int rfbPeekExactTimeout(rfbClientPtr cl, char *buf, int len,int timeout); 751 extern int rfbWriteExact(rfbClientPtr cl, const char *buf, int len); 752 extern int rfbCheckFds(rfbScreenInfoPtr rfbScreen,long usec); 753 extern int rfbConnect(rfbScreenInfoPtr rfbScreen, char* host, int port); 754 extern int rfbConnectToTcpAddr(char* host, int port); 755 extern int rfbListenOnTCPPort(int port, in_addr_t iface); 756 extern int rfbListenOnTCP6Port(int port, const char* iface); 757 extern int rfbListenOnUDPPort(int port, in_addr_t iface); 758 extern int rfbStringToAddr(char* string,in_addr_t* addr); 759 extern rfbBool rfbSetNonBlocking(int sock); 760 761 #ifdef LIBVNCSERVER_WITH_WEBSOCKETS 762 /* websockets.c */ 763 764 extern rfbBool webSocketsCheck(rfbClientPtr cl); 765 extern rfbBool webSocketCheckDisconnect(rfbClientPtr cl); 766 extern int webSocketsEncode(rfbClientPtr cl, const char *src, int len, char **dst); 767 extern int webSocketsDecode(rfbClientPtr cl, char *dst, int len); 768 #endif 769 770 /* rfbserver.c */ 771 772 /* Routines to iterate over the client list in a thread-safe way. 773 Only a single iterator can be in use at a time process-wide. */ 774 typedef struct rfbClientIterator *rfbClientIteratorPtr; 775 776 extern void rfbClientListInit(rfbScreenInfoPtr rfbScreen); 777 extern rfbClientIteratorPtr rfbGetClientIterator(rfbScreenInfoPtr rfbScreen); 778 extern rfbClientPtr rfbClientIteratorNext(rfbClientIteratorPtr iterator); 779 extern void rfbReleaseClientIterator(rfbClientIteratorPtr iterator); 780 extern void rfbIncrClientRef(rfbClientPtr cl); 781 extern void rfbDecrClientRef(rfbClientPtr cl); 782 783 extern void rfbNewClientConnection(rfbScreenInfoPtr rfbScreen,int sock); 784 extern rfbClientPtr rfbNewClient(rfbScreenInfoPtr rfbScreen,int sock); 785 extern rfbClientPtr rfbNewUDPClient(rfbScreenInfoPtr rfbScreen); 786 extern rfbClientPtr rfbReverseConnection(rfbScreenInfoPtr rfbScreen,char *host, int port); 787 extern void rfbClientConnectionGone(rfbClientPtr cl); 788 extern void rfbProcessClientMessage(rfbClientPtr cl); 789 extern void rfbClientConnFailed(rfbClientPtr cl, const char *reason); 790 extern void rfbNewUDPConnection(rfbScreenInfoPtr rfbScreen,int sock); 791 extern void rfbProcessUDPInput(rfbScreenInfoPtr rfbScreen); 792 extern rfbBool rfbSendFramebufferUpdate(rfbClientPtr cl, sraRegionPtr updateRegion); 793 extern rfbBool rfbSendRectEncodingRaw(rfbClientPtr cl, int x,int y,int w,int h); 794 extern rfbBool rfbSendUpdateBuf(rfbClientPtr cl); 795 extern void rfbSendServerCutText(rfbScreenInfoPtr rfbScreen,char *str, int len); 796 extern rfbBool rfbSendCopyRegion(rfbClientPtr cl,sraRegionPtr reg,int dx,int dy); 797 extern rfbBool rfbSendLastRectMarker(rfbClientPtr cl); 798 extern rfbBool rfbSendNewFBSize(rfbClientPtr cl, int w, int h); 799 extern rfbBool rfbSendSetColourMapEntries(rfbClientPtr cl, int firstColour, int nColours); 800 extern void rfbSendBell(rfbScreenInfoPtr rfbScreen); 801 802 extern char *rfbProcessFileTransferReadBuffer(rfbClientPtr cl, uint32_t length); 803 extern rfbBool rfbSendFileTransferChunk(rfbClientPtr cl); 804 extern rfbBool rfbSendDirContent(rfbClientPtr cl, int length, char *buffer); 805 extern rfbBool rfbSendFileTransferMessage(rfbClientPtr cl, uint8_t contentType, uint8_t contentParam, uint32_t size, uint32_t length, const char *buffer); 806 extern char *rfbProcessFileTransferReadBuffer(rfbClientPtr cl, uint32_t length); 807 extern rfbBool rfbProcessFileTransfer(rfbClientPtr cl, uint8_t contentType, uint8_t contentParam, uint32_t size, uint32_t length); 808 809 void rfbGotXCutText(rfbScreenInfoPtr rfbScreen, char *str, int len); 810 811 /* translate.c */ 812 813 extern rfbBool rfbEconomicTranslate; 814 815 extern void rfbTranslateNone(char *table, rfbPixelFormat *in, 816 rfbPixelFormat *out, 817 char *iptr, char *optr, 818 int bytesBetweenInputLines, 819 int width, int height); 820 extern rfbBool rfbSetTranslateFunction(rfbClientPtr cl); 821 extern rfbBool rfbSetClientColourMap(rfbClientPtr cl, int firstColour, int nColours); 822 extern void rfbSetClientColourMaps(rfbScreenInfoPtr rfbScreen, int firstColour, int nColours); 823 824 /* httpd.c */ 825 826 extern void rfbHttpInitSockets(rfbScreenInfoPtr rfbScreen); 827 extern void rfbHttpShutdownSockets(rfbScreenInfoPtr rfbScreen); 828 extern void rfbHttpCheckFds(rfbScreenInfoPtr rfbScreen); 829 830 831 832 /* auth.c */ 833 834 extern void rfbAuthNewClient(rfbClientPtr cl); 835 extern void rfbProcessClientSecurityType(rfbClientPtr cl); 836 extern void rfbAuthProcessClientMessage(rfbClientPtr cl); 837 extern void rfbRegisterSecurityHandler(rfbSecurityHandler* handler); 838 extern void rfbUnregisterSecurityHandler(rfbSecurityHandler* handler); 839 840 /* rre.c */ 841 842 extern rfbBool rfbSendRectEncodingRRE(rfbClientPtr cl, int x,int y,int w,int h); 843 844 845 /* corre.c */ 846 847 extern rfbBool rfbSendRectEncodingCoRRE(rfbClientPtr cl, int x,int y,int w,int h); 848 849 850 /* hextile.c */ 851 852 extern rfbBool rfbSendRectEncodingHextile(rfbClientPtr cl, int x, int y, int w, 853 int h); 854 855 /* ultra.c */ 856 857 /* Set maximum ultra rectangle size in pixels. Always allow at least 858 * two scan lines. 859 */ 860 #define ULTRA_MAX_RECT_SIZE (128*256) 861 #define ULTRA_MAX_SIZE(min) ((( min * 2 ) > ULTRA_MAX_RECT_SIZE ) ? \ 862 ( min * 2 ) : ULTRA_MAX_RECT_SIZE ) 863 864 extern rfbBool rfbSendRectEncodingUltra(rfbClientPtr cl, int x,int y,int w,int h); 865 866 867 #ifdef LIBVNCSERVER_HAVE_LIBZ 868 /* zlib.c */ 869 870 /** Minimum zlib rectangle size in bytes. Anything smaller will 871 * not compress well due to overhead. 872 */ 873 #define VNC_ENCODE_ZLIB_MIN_COMP_SIZE (17) 874 875 /* Set maximum zlib rectangle size in pixels. Always allow at least 876 * two scan lines. 877 */ 878 #define ZLIB_MAX_RECT_SIZE (128*256) 879 #define ZLIB_MAX_SIZE(min) ((( min * 2 ) > ZLIB_MAX_RECT_SIZE ) ? \ 880 ( min * 2 ) : ZLIB_MAX_RECT_SIZE ) 881 882 extern rfbBool rfbSendRectEncodingZlib(rfbClientPtr cl, int x, int y, int w, 883 int h); 884 885 #ifdef LIBVNCSERVER_HAVE_LIBJPEG 886 /* tight.c */ 887 888 #define TIGHT_DEFAULT_COMPRESSION 6 889 #define TURBO_DEFAULT_SUBSAMP 0 890 891 extern rfbBool rfbTightDisableGradient; 892 893 extern int rfbNumCodedRectsTight(rfbClientPtr cl, int x,int y,int w,int h); 894 895 extern rfbBool rfbSendRectEncodingTight(rfbClientPtr cl, int x,int y,int w,int h); 896 897 #if defined(LIBVNCSERVER_HAVE_LIBPNG) 898 extern rfbBool rfbSendRectEncodingTightPng(rfbClientPtr cl, int x,int y,int w,int h); 899 #endif 900 901 #endif 902 #endif 903 904 905 /* cursor.c */ 906 907 typedef struct rfbCursor { 908 /** set this to true if LibVNCServer has to free this cursor */ 909 rfbBool cleanup, cleanupSource, cleanupMask, cleanupRichSource; 910 unsigned char *source; /**< points to bits */ 911 unsigned char *mask; /**< points to bits */ 912 unsigned short width, height, xhot, yhot; /**< metrics */ 913 unsigned short foreRed, foreGreen, foreBlue; /**< device-independent colour */ 914 unsigned short backRed, backGreen, backBlue; /**< device-independent colour */ 915 unsigned char *richSource; /**< source bytes for a rich cursor */ 916 unsigned char *alphaSource; /**< source for alpha blending info */ 917 rfbBool alphaPreMultiplied; /**< if richSource already has alpha applied */ 918 } rfbCursor, *rfbCursorPtr; 919 extern unsigned char rfbReverseByte[0x100]; 920 921 extern rfbBool rfbSendCursorShape(rfbClientPtr cl/*, rfbScreenInfoPtr pScreen*/); 922 extern rfbBool rfbSendCursorPos(rfbClientPtr cl); 923 extern void rfbConvertLSBCursorBitmapOrMask(int width,int height,unsigned char* bitmap); 924 extern rfbCursorPtr rfbMakeXCursor(int width,int height,char* cursorString,char* maskString); 925 extern char* rfbMakeMaskForXCursor(int width,int height,char* cursorString); 926 extern char* rfbMakeMaskFromAlphaSource(int width,int height,unsigned char* alphaSource); 927 extern void rfbMakeXCursorFromRichCursor(rfbScreenInfoPtr rfbScreen,rfbCursorPtr cursor); 928 extern void rfbMakeRichCursorFromXCursor(rfbScreenInfoPtr rfbScreen,rfbCursorPtr cursor); 929 extern void rfbFreeCursor(rfbCursorPtr cursor); 930 extern void rfbSetCursor(rfbScreenInfoPtr rfbScreen,rfbCursorPtr c); 931 932 /** cursor handling for the pointer */ 933 extern void rfbDefaultPtrAddEvent(int buttonMask,int x,int y,rfbClientPtr cl); 934 935 /* zrle.c */ 936 #ifdef LIBVNCSERVER_HAVE_LIBZ 937 extern rfbBool rfbSendRectEncodingZRLE(rfbClientPtr cl, int x, int y, int w,int h); 938 #endif 939 940 /* stats.c */ 941 942 extern void rfbResetStats(rfbClientPtr cl); 943 extern void rfbPrintStats(rfbClientPtr cl); 944 945 /* font.c */ 946 947 typedef struct rfbFontData { 948 unsigned char* data; 949 /** 950 metaData is a 256*5 array: 951 for each character 952 (offset,width,height,x,y) 953 */ 954 int* metaData; 955 } rfbFontData,* rfbFontDataPtr; 956 957 int rfbDrawChar(rfbScreenInfoPtr rfbScreen,rfbFontDataPtr font,int x,int y,unsigned char c,rfbPixel colour); 958 void rfbDrawString(rfbScreenInfoPtr rfbScreen,rfbFontDataPtr font,int x,int y,const char* string,rfbPixel colour); 959 /** if colour==backColour, background is transparent */ 960 int rfbDrawCharWithClip(rfbScreenInfoPtr rfbScreen,rfbFontDataPtr font,int x,int y,unsigned char c,int x1,int y1,int x2,int y2,rfbPixel colour,rfbPixel backColour); 961 void rfbDrawStringWithClip(rfbScreenInfoPtr rfbScreen,rfbFontDataPtr font,int x,int y,const char* string,int x1,int y1,int x2,int y2,rfbPixel colour,rfbPixel backColour); 962 int rfbWidthOfString(rfbFontDataPtr font,const char* string); 963 int rfbWidthOfChar(rfbFontDataPtr font,unsigned char c); 964 void rfbFontBBox(rfbFontDataPtr font,unsigned char c,int* x1,int* y1,int* x2,int* y2); 965 /** this returns the smallest box enclosing any character of font. */ 966 void rfbWholeFontBBox(rfbFontDataPtr font,int *x1, int *y1, int *x2, int *y2); 967 968 /** dynamically load a linux console font (4096 bytes, 256 glyphs a 8x16 */ 969 rfbFontDataPtr rfbLoadConsoleFont(char *filename); 970 /** free a dynamically loaded font */ 971 void rfbFreeFont(rfbFontDataPtr font); 972 973 /* draw.c */ 974 975 void rfbFillRect(rfbScreenInfoPtr s,int x1,int y1,int x2,int y2,rfbPixel col); 976 void rfbDrawPixel(rfbScreenInfoPtr s,int x,int y,rfbPixel col); 977 void rfbDrawLine(rfbScreenInfoPtr s,int x1,int y1,int x2,int y2,rfbPixel col); 978 979 /* selbox.c */ 980 981 /** this opens a modal select box. list is an array of strings, the end marked 982 with a NULL. 983 It returns the index in the list or -1 if cancelled or something else 984 wasn't kosher. */ 985 typedef void (*SelectionChangedHookPtr)(int _index); 986 extern int rfbSelectBox(rfbScreenInfoPtr rfbScreen, 987 rfbFontDataPtr font, char** list, 988 int x1, int y1, int x2, int y2, 989 rfbPixel foreColour, rfbPixel backColour, 990 int border,SelectionChangedHookPtr selChangedHook); 991 992 /* cargs.c */ 993 994 extern void rfbUsage(void); 995 extern void rfbPurgeArguments(int* argc,int* position,int count,char *argv[]); 996 extern rfbBool rfbProcessArguments(rfbScreenInfoPtr rfbScreen,int* argc, char *argv[]); 997 extern rfbBool rfbProcessSizeArguments(int* width,int* height,int* bpp,int* argc, char *argv[]); 998 999 /* main.c */ 1000 1001 extern void rfbLogEnable(int enabled); 1002 typedef void (*rfbLogProc)(const char *format, ...); 1003 extern rfbLogProc rfbLog, rfbErr; 1004 extern void rfbLogPerror(const char *str); 1005 1006 void rfbScheduleCopyRect(rfbScreenInfoPtr rfbScreen,int x1,int y1,int x2,int y2,int dx,int dy); 1007 void rfbScheduleCopyRegion(rfbScreenInfoPtr rfbScreen,sraRegionPtr copyRegion,int dx,int dy); 1008 1009 void rfbDoCopyRect(rfbScreenInfoPtr rfbScreen,int x1,int y1,int x2,int y2,int dx,int dy); 1010 void rfbDoCopyRegion(rfbScreenInfoPtr rfbScreen,sraRegionPtr copyRegion,int dx,int dy); 1011 1012 void rfbMarkRectAsModified(rfbScreenInfoPtr rfbScreen,int x1,int y1,int x2,int y2); 1013 void rfbMarkRegionAsModified(rfbScreenInfoPtr rfbScreen,sraRegionPtr modRegion); 1014 void rfbDoNothingWithClient(rfbClientPtr cl); 1015 enum rfbNewClientAction defaultNewClientHook(rfbClientPtr cl); 1016 void rfbRegisterProtocolExtension(rfbProtocolExtension* extension); 1017 void rfbUnregisterProtocolExtension(rfbProtocolExtension* extension); 1018 struct _rfbProtocolExtension* rfbGetExtensionIterator(); 1019 void rfbReleaseExtensionIterator(); 1020 rfbBool rfbEnableExtension(rfbClientPtr cl, rfbProtocolExtension* extension, 1021 void* data); 1022 rfbBool rfbDisableExtension(rfbClientPtr cl, rfbProtocolExtension* extension); 1023 void* rfbGetExtensionClientData(rfbClientPtr cl, rfbProtocolExtension* extension); 1024 1025 /** to check against plain passwords */ 1026 rfbBool rfbCheckPasswordByList(rfbClientPtr cl,const char* response,int len); 1027 1028 /* functions to make a vnc server */ 1029 extern rfbScreenInfoPtr rfbGetScreen(int* argc,char** argv, 1030 int width,int height,int bitsPerSample,int samplesPerPixel, 1031 int bytesPerPixel); 1032 extern void rfbInitServer(rfbScreenInfoPtr rfbScreen); 1033 extern void rfbShutdownServer(rfbScreenInfoPtr rfbScreen,rfbBool disconnectClients); 1034 extern void rfbNewFramebuffer(rfbScreenInfoPtr rfbScreen,char *framebuffer, 1035 int width,int height, int bitsPerSample,int samplesPerPixel, 1036 int bytesPerPixel); 1037 1038 extern void rfbScreenCleanup(rfbScreenInfoPtr screenInfo); 1039 extern void rfbSetServerVersionIdentity(rfbScreenInfoPtr screen, char *fmt, ...); 1040 1041 /* functions to accept/refuse a client that has been put on hold 1042 by a NewClientHookPtr function. Must not be called in other 1043 situations. */ 1044 extern void rfbStartOnHoldClient(rfbClientPtr cl); 1045 extern void rfbRefuseOnHoldClient(rfbClientPtr cl); 1046 1047 /* call one of these two functions to service the vnc clients. 1048 usec are the microseconds the select on the fds waits. 1049 if you are using the event loop, set this to some value > 0, so the 1050 server doesn't get a high load just by listening. 1051 rfbProcessEvents() returns TRUE if an update was pending. */ 1052 1053 extern void rfbRunEventLoop(rfbScreenInfoPtr screenInfo, long usec, rfbBool runInBackground); 1054 extern rfbBool rfbProcessEvents(rfbScreenInfoPtr screenInfo,long usec); 1055 extern rfbBool rfbIsActive(rfbScreenInfoPtr screenInfo); 1056 1057 /* TightVNC file transfer extension */ 1058 void rfbRegisterTightVNCFileTransferExtension(); 1059 void rfbUnregisterTightVNCFileTransferExtension(); 1060 1061 /* Statistics */ 1062 extern char *messageNameServer2Client(uint32_t type, char *buf, int len); 1063 extern char *messageNameClient2Server(uint32_t type, char *buf, int len); 1064 extern char *encodingName(uint32_t enc, char *buf, int len); 1065 1066 extern rfbStatList *rfbStatLookupEncoding(rfbClientPtr cl, uint32_t type); 1067 extern rfbStatList *rfbStatLookupMessage(rfbClientPtr cl, uint32_t type); 1068 1069 /* Each call to rfbStatRecord* adds one to the rect count for that type */ 1070 extern void rfbStatRecordEncodingSent(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw); 1071 extern void rfbStatRecordEncodingSentAdd(rfbClientPtr cl, uint32_t type, int byteCount); /* Specifically for tight encoding */ 1072 extern void rfbStatRecordEncodingRcvd(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw); 1073 extern void rfbStatRecordMessageSent(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw); 1074 extern void rfbStatRecordMessageRcvd(rfbClientPtr cl, uint32_t type, int byteCount, int byteIfRaw); 1075 extern void rfbResetStats(rfbClientPtr cl); 1076 extern void rfbPrintStats(rfbClientPtr cl); 1077 1078 extern int rfbStatGetSentBytes(rfbClientPtr cl); 1079 extern int rfbStatGetSentBytesIfRaw(rfbClientPtr cl); 1080 extern int rfbStatGetRcvdBytes(rfbClientPtr cl); 1081 extern int rfbStatGetRcvdBytesIfRaw(rfbClientPtr cl); 1082 extern int rfbStatGetMessageCountSent(rfbClientPtr cl, uint32_t type); 1083 extern int rfbStatGetMessageCountRcvd(rfbClientPtr cl, uint32_t type); 1084 extern int rfbStatGetEncodingCountSent(rfbClientPtr cl, uint32_t type); 1085 extern int rfbStatGetEncodingCountRcvd(rfbClientPtr cl, uint32_t type); 1086 1087 /** Set which version you want to advertise 3.3, 3.6, 3.7 and 3.8 are currently supported*/ 1088 extern void rfbSetProtocolVersion(rfbScreenInfoPtr rfbScreen, int major_, int minor_); 1089 1090 /** send a TextChat message to a client */ 1091 extern rfbBool rfbSendTextChatMessage(rfbClientPtr cl, uint32_t length, char *buffer); 1092 1093 1094 /* 1095 * Additions for Qt event loop integration 1096 * Original idea taken from vino. 1097 */ 1098 rfbBool rfbProcessNewConnection(rfbScreenInfoPtr rfbScreen); 1099 rfbBool rfbUpdateClient(rfbClientPtr cl); 1100 1101 1102 #if(defined __cplusplus) 1103 } 1104 #endif 1105 1106 /** 1107 * @} 1108 */ 1109 1110 1111 /** 1112 @page libvncserver_doc LibVNCServer Documentation 1113 @section create_server Creating a server instance 1114 To make a server, you just have to initialise a server structure using the 1115 function rfbGetScreen(), like 1116 @code 1117 rfbScreenInfoPtr screen = 1118 rfbGetScreen(argc,argv,screenwidth,screenheight,8,3,bpp); 1119 @endcode 1120 where byte per pixel should be 1, 2 or 4. If performance doesn't matter, 1121 you may try bpp=3 (internally one cannot use native data types in this 1122 case; if you want to use this, look at pnmshow24.c). 1123 1124 You then can set hooks and io functions (see @ref making_it_interactive) or other 1125 options (see @ref server_options). 1126 1127 And you allocate the frame buffer like this: 1128 @code 1129 screen->frameBuffer = (char*)malloc(screenwidth*screenheight*bpp); 1130 @endcode 1131 After that, you initialize the server, like 1132 @code 1133 rfbInitServer(screen); 1134 @endcode 1135 You can use a blocking event loop, a background (pthread based) event loop, 1136 or implement your own using the rfbProcessEvents() function. 1137 1138 @subsection server_options Optional Server Features 1139 1140 These options have to be set between rfbGetScreen() and rfbInitServer(). 1141 1142 If you already have a socket to talk to, just set rfbScreenInfo::inetdSock 1143 (originally this is for inetd handling, but why not use it for your purpose?). 1144 1145 To also start an HTTP server (running on port 5800+display_number), you have 1146 to set rfbScreenInfo::httpDir to a directory containing vncviewer.jar and 1147 index.vnc (like the included "webclients" directory). 1148 1149 @section making_it_interactive Making it interactive 1150 1151 Whenever you draw something, you have to call 1152 @code 1153 rfbMarkRectAsModified(screen,x1,y1,x2,y2). 1154 @endcode 1155 This tells LibVNCServer to send updates to all connected clients. 1156 1157 There exist the following IO functions as members of rfbScreen: 1158 rfbScreenInfo::kbdAddEvent(), rfbScreenInfo::kbdReleaseAllKeys(), rfbScreenInfo::ptrAddEvent() and rfbScreenInfo::setXCutText() 1159 1160 rfbScreenInfo::kbdAddEvent() 1161 is called when a key is pressed. 1162 rfbScreenInfo::kbdReleaseAllKeys() 1163 is not called at all (maybe in the future). 1164 rfbScreenInfo::ptrAddEvent() 1165 is called when the mouse moves or a button is pressed. 1166 WARNING: if you want to have proper cursor handling, call 1167 rfbDefaultPtrAddEvent() 1168 in your own function. This sets the coordinates of the cursor. 1169 rfbScreenInfo::setXCutText() 1170 is called when the selection changes. 1171 1172 There are only two hooks: 1173 rfbScreenInfo::newClientHook() 1174 is called when a new client has connected. 1175 rfbScreenInfo::displayHook() 1176 is called just before a frame buffer update is sent. 1177 1178 You can also override the following methods: 1179 rfbScreenInfo::getCursorPtr() 1180 This could be used to make an animated cursor (if you really want ...) 1181 rfbScreenInfo::setTranslateFunction() 1182 If you insist on colour maps or something more obscure, you have to 1183 implement this. Default is a trueColour mapping. 1184 1185 @section cursor_handling Cursor handling 1186 1187 The screen holds a pointer 1188 rfbScreenInfo::cursor 1189 to the current cursor. Whenever you set it, remember that any dynamically 1190 created cursor (like return value from rfbMakeXCursor()) is not free'd! 1191 1192 The rfbCursor structure consists mainly of a mask and a source. The rfbCursor::mask 1193 describes, which pixels are drawn for the cursor (a cursor needn't be 1194 rectangular). The rfbCursor::source describes, which colour those pixels should have. 1195 1196 The standard is an XCursor: a cursor with a foreground and a background 1197 colour (stored in backRed,backGreen,backBlue and the same for foreground 1198 in a range from 0-0xffff). Therefore, the arrays "mask" and "source" 1199 contain pixels as single bits stored in bytes in MSB order. The rows are 1200 padded, such that each row begins with a new byte (i.e. a 10x4 1201 cursor's mask has 2x4 bytes, because 2 bytes are needed to hold 10 bits). 1202 1203 It is however very easy to make a cursor like this: 1204 @code 1205 char* cur=" " 1206 " xx " 1207 " x " 1208 " "; 1209 char* mask="xxxx" 1210 "xxxx" 1211 "xxxx" 1212 "xxx "; 1213 rfbCursorPtr c=rfbMakeXCursor(4,4,cur,mask); 1214 @endcode 1215 You can even set rfbCursor::mask to NULL in this call and LibVNCServer will calculate 1216 a mask for you (dynamically, so you have to free it yourself). 1217 1218 There is also an array named rfbCursor::richSource for colourful cursors. They have 1219 the same format as the frameBuffer (i.e. if the server is 32 bit, 1220 a 10x4 cursor has 4x10x4 bytes). 1221 1222 @section screen_client_difference What is the difference between rfbScreenInfoPtr and rfbClientPtr? 1223 1224 The rfbScreenInfoPtr is a pointer to a rfbScreenInfo structure, which 1225 holds information about the server, like pixel format, io functions, 1226 frame buffer etc. The rfbClientPtr is a pointer to an rfbClientRec structure, which holds 1227 information about a client, like pixel format, socket of the 1228 connection, etc. A server can have several clients, but needn't have any. So, if you 1229 have a server and three clients are connected, you have one instance 1230 of a rfbScreenInfo and three instances of rfbClientRec's. 1231 1232 The rfbClientRec structure holds a member rfbClientRec::screen which points to the server. 1233 So, to access the server from the client structure, you use client->screen. 1234 1235 To access all clients from a server be sure to use the provided iterator 1236 rfbGetClientIterator() 1237 with 1238 rfbClientIteratorNext() 1239 and 1240 rfbReleaseClientIterator() 1241 to prevent thread clashes. 1242 1243 @section example_code Example Code 1244 1245 There are two documented examples included: 1246 - example.c, a shared scribble sheet 1247 - pnmshow.c, a program to show PNMs (pictures) over the net. 1248 1249 The examples are not too well documented, but easy straight forward and a 1250 good starting point. 1251 1252 Try example.c: it outputs on which port it listens (default: 5900), so it is 1253 display 0. To view, call @code vncviewer :0 @endcode 1254 You should see a sheet with a gradient and "Hello World!" written on it. Try 1255 to paint something. Note that everytime you click, there is some bigger blot, 1256 whereas when you drag the mouse while clicked you draw a line. The size of the 1257 blot depends on the mouse button you click. Open a second vncviewer with 1258 the same parameters and watch it as you paint in the other window. This also 1259 works over internet. You just have to know either the name or the IP of your 1260 machine. Then it is @code vncviewer machine.where.example.runs.com:0 @endcode 1261 or similar for the remote client. Now you are ready to type something. Be sure 1262 that your mouse sits still, because everytime the mouse moves, the cursor is 1263 reset to the position of the pointer! If you are done with that demo, press 1264 the down or up arrows. If your viewer supports it, then the dimensions of the 1265 sheet change. Just press Escape in the viewer. Note that the server still 1266 runs, even if you closed both windows. When you reconnect now, everything you 1267 painted and wrote is still there. You can press "Page Up" for a blank page. 1268 1269 The demo pnmshow.c is much simpler: you either provide a filename as argument 1270 or pipe a file through stdin. Note that the file has to be a raw pnm/ppm file, 1271 i.e. a truecolour graphics. Only the Escape key is implemented. This may be 1272 the best starting point if you want to learn how to use LibVNCServer. You 1273 are confronted with the fact that the bytes per pixel can only be 8, 16 or 32. 1274 */ 1275 1276 #endif 1277
