1 #ifndef RFBPROTO_H 2 #define RFBPROTO_H 3 4 /** 5 @mainpage 6 @li @ref libvncserver_api 7 @li @ref libvncserver_doc 8 9 10 @li @ref libvncclient_api 11 @li @ref libvncclient_doc 12 13 */ 14 15 /* 16 * Copyright (C) 2009-2010 D. R. Commander. All Rights Reserved. 17 * Copyright (C) 2005 Rohit Kumar, Johannes E. Schindelin 18 * Copyright (C) 2004-2008 Sun Microsystems, Inc. All Rights Reserved. 19 * Copyright (C) 2000-2002 Constantin Kaplinsky. All Rights Reserved. 20 * Copyright (C) 2000 Tridia Corporation. All Rights Reserved. 21 * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. 22 * 23 * This is free software; you can redistribute it and/or modify 24 * it under the terms of the GNU General Public License as published by 25 * the Free Software Foundation; either version 2 of the License, or 26 * (at your option) any later version. 27 * 28 * This software is distributed in the hope that it will be useful, 29 * but WITHOUT ANY WARRANTY; without even the implied warranty of 30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 31 * GNU General Public License for more details. 32 * 33 * You should have received a copy of the GNU General Public License 34 * along with this software; if not, write to the Free Software 35 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 36 * USA. 37 */ 38 39 /* 40 * rfbproto.h - header file for the RFB protocol version 3.3 41 * 42 * Uses types CARD<n> for an n-bit unsigned integer, INT<n> for an n-bit signed 43 * integer (for n = 8, 16 and 32). 44 * 45 * All multiple byte integers are in big endian (network) order (most 46 * significant byte first). Unless noted otherwise there is no special 47 * alignment of protocol structures. 48 * 49 * 50 * Once the initial handshaking is done, all messages start with a type byte, 51 * (usually) followed by message-specific data. The order of definitions in 52 * this file is as follows: 53 * 54 * (1) Structures used in several types of message. 55 * (2) Structures used in the initial handshaking. 56 * (3) Message types. 57 * (4) Encoding types. 58 * (5) For each message type, the form of the data following the type byte. 59 * Sometimes this is defined by a single structure but the more complex 60 * messages have to be explained by comments. 61 */ 62 63 64 #if defined(WIN32) && !defined(__MINGW32__) 65 #define LIBVNCSERVER_WORDS_BIGENDIAN 66 #define rfbBool int 67 #include <sys/timeb.h> 68 #include <winsock.h> 69 #undef SOCKET 70 #define SOCKET int 71 #else 72 #include <rfb/rfbconfig.h> 73 #include <rfb/rfbint.h> 74 #endif 75 76 #ifdef LIBVNCSERVER_HAVE_LIBZ 77 #include <zlib.h> 78 #ifdef __CHECKER__ 79 #undef Z_NULL 80 #define Z_NULL NULL 81 #endif 82 #endif 83 84 /* some autotool versions do not properly prefix 85 WORDS_BIGENDIAN, so do that manually */ 86 #ifdef WORDS_BIGENDIAN 87 #define LIBVNCSERVER_WORDS_BIGENDIAN 88 #endif 89 90 /* MS compilers don't have strncasecmp */ 91 #ifdef _MSC_VER 92 #define strncasecmp _strnicmp 93 #endif 94 95 #if !defined(WIN32) || defined(__MINGW32__) 96 #define max(a,b) (((a)>(b))?(a):(b)) 97 #ifdef LIBVNCSERVER_HAVE_SYS_TIME_H 98 #include <sys/time.h> 99 #endif 100 #ifdef LIBVNCSERVER_HAVE_NETINET_IN_H 101 #include <netinet/in.h> 102 #endif 103 #define SOCKET int 104 typedef int8_t rfbBool; 105 #undef FALSE 106 #define FALSE 0 107 #undef TRUE 108 #define TRUE -1 109 #endif 110 111 typedef uint32_t rfbKeySym; 112 typedef uint32_t rfbPixel; 113 114 #ifdef LIBVNCSERVER_NEED_INADDR_T 115 typedef uint32_t in_addr_t; 116 #endif 117 118 #ifndef INADDR_NONE 119 #define INADDR_NONE ((in_addr_t) 0xffffffff) 120 #endif 121 122 #define MAX_ENCODINGS 21 123 124 /***************************************************************************** 125 * 126 * Structures used in several messages 127 * 128 *****************************************************************************/ 129 130 /*----------------------------------------------------------------------------- 131 * Structure used to specify a rectangle. This structure is a multiple of 4 132 * bytes so that it can be interspersed with 32-bit pixel data without 133 * affecting alignment. 134 */ 135 136 typedef struct { 137 uint16_t x; 138 uint16_t y; 139 uint16_t w; 140 uint16_t h; 141 } rfbRectangle; 142 143 #define sz_rfbRectangle 8 144 145 146 /*----------------------------------------------------------------------------- 147 * Structure used to specify pixel format. 148 */ 149 150 typedef struct { 151 152 uint8_t bitsPerPixel; /* 8,16,32 only */ 153 154 uint8_t depth; /* 8 to 32 */ 155 156 uint8_t bigEndian; /* True if multi-byte pixels are interpreted 157 as big endian, or if single-bit-per-pixel 158 has most significant bit of the byte 159 corresponding to first (leftmost) pixel. Of 160 course this is meaningless for 8 bits/pix */ 161 162 uint8_t trueColour; /* If false then we need a "colour map" to 163 convert pixels to RGB. If true, xxxMax and 164 xxxShift specify bits used for red, green 165 and blue */ 166 167 /* the following fields are only meaningful if trueColour is true */ 168 169 uint16_t redMax; /* maximum red value (= 2^n - 1 where n is the 170 number of bits used for red). Note this 171 value is always in big endian order. */ 172 173 uint16_t greenMax; /* similar for green */ 174 175 uint16_t blueMax; /* and blue */ 176 177 uint8_t redShift; /* number of shifts needed to get the red 178 value in a pixel to the least significant 179 bit. To find the red value from a given 180 pixel, do the following: 181 1) Swap pixel value according to bigEndian 182 (e.g. if bigEndian is false and host byte 183 order is big endian, then swap). 184 2) Shift right by redShift. 185 3) AND with redMax (in host byte order). 186 4) You now have the red value between 0 and 187 redMax. */ 188 189 uint8_t greenShift; /* similar for green */ 190 191 uint8_t blueShift; /* and blue */ 192 193 uint8_t pad1; 194 uint16_t pad2; 195 196 } rfbPixelFormat; 197 198 #define sz_rfbPixelFormat 16 199 200 /* UltraVNC: Color settings values */ 201 #define rfbPFFullColors 0 202 #define rfbPF256Colors 1 203 #define rfbPF64Colors 2 204 #define rfbPF8Colors 3 205 #define rfbPF8GreyColors 4 206 #define rfbPF4GreyColors 5 207 #define rfbPF2GreyColors 6 208 209 210 /***************************************************************************** 211 * 212 * Initial handshaking messages 213 * 214 *****************************************************************************/ 215 216 /*----------------------------------------------------------------------------- 217 * Protocol Version 218 * 219 * The server always sends 12 bytes to start which identifies the latest RFB 220 * protocol version number which it supports. These bytes are interpreted 221 * as a string of 12 ASCII characters in the format "RFB xxx.yyy\n" where 222 * xxx and yyy are the major and minor version numbers (for version 3.3 223 * this is "RFB 003.003\n"). 224 * 225 * The client then replies with a similar 12-byte message giving the version 226 * number of the protocol which should actually be used (which may be different 227 * to that quoted by the server). 228 * 229 * It is intended that both clients and servers may provide some level of 230 * backwards compatibility by this mechanism. Servers in particular should 231 * attempt to provide backwards compatibility, and even forwards compatibility 232 * to some extent. For example if a client demands version 3.1 of the 233 * protocol, a 3.0 server can probably assume that by ignoring requests for 234 * encoding types it doesn't understand, everything will still work OK. This 235 * will probably not be the case for changes in the major version number. 236 * 237 * The format string below can be used in sprintf or sscanf to generate or 238 * decode the version string respectively. 239 */ 240 241 #define rfbProtocolVersionFormat "RFB %03d.%03d\n" 242 #define rfbProtocolMajorVersion 3 243 #define rfbProtocolMinorVersion 8 244 /* UltraVNC Viewer examines rfbProtocolMinorVersion number (4, and 6) 245 * to identify if the server supports File Transfer 246 */ 247 248 typedef char rfbProtocolVersionMsg[13]; /* allow extra byte for null */ 249 250 #define sz_rfbProtocolVersionMsg 12 251 252 /* 253 * Negotiation of the security type (protocol version 3.7) 254 * 255 * Once the protocol version has been decided, the server either sends a list 256 * of supported security types, or informs the client about an error (when the 257 * number of security types is 0). Security type rfbSecTypeTight is used to 258 * enable TightVNC-specific protocol extensions. The value rfbSecTypeVncAuth 259 * stands for classic VNC authentication. 260 * 261 * The client selects a particular security type from the list provided by the 262 * server. 263 */ 264 265 #define rfbSecTypeInvalid 0 266 #define rfbSecTypeNone 1 267 #define rfbSecTypeVncAuth 2 268 269 270 /*----------------------------------------------------------------------------- 271 * Authentication 272 * 273 * Once the protocol version has been decided, the server then sends a 32-bit 274 * word indicating whether any authentication is needed on the connection. 275 * The value of this word determines the authentication scheme in use. For 276 * version 3.0 of the protocol this may have one of the following values: 277 */ 278 279 #define rfbConnFailed 0 280 #define rfbNoAuth 1 281 #define rfbVncAuth 2 282 283 #define rfbRA2 5 284 #define rfbRA2ne 6 285 #define rfbSSPI 7 286 #define rfbSSPIne 8 287 #define rfbTight 16 288 #define rfbUltra 17 289 #define rfbTLS 18 290 #define rfbVeNCrypt 19 291 #define rfbARD 30 292 #define rfbMSLogon 0xfffffffa 293 294 #define rfbVeNCryptPlain 256 295 #define rfbVeNCryptTLSNone 257 296 #define rfbVeNCryptTLSVNC 258 297 #define rfbVeNCryptTLSPlain 259 298 #define rfbVeNCryptX509None 260 299 #define rfbVeNCryptX509VNC 261 300 #define rfbVeNCryptX509Plain 262 301 #define rfbVeNCryptX509SASL 263 302 #define rfbVeNCryptTLSSASL 264 303 304 /* 305 * rfbConnFailed: For some reason the connection failed (e.g. the server 306 * cannot support the desired protocol version). This is 307 * followed by a string describing the reason (where a 308 * string is specified as a 32-bit length followed by that 309 * many ASCII characters). 310 * 311 * rfbNoAuth: No authentication is needed. 312 * 313 * rfbVncAuth: The VNC authentication scheme is to be used. A 16-byte 314 * challenge follows, which the client encrypts as 315 * appropriate using the password and sends the resulting 316 * 16-byte response. If the response is correct, the 317 * server sends the 32-bit word rfbVncAuthOK. If a simple 318 * failure happens, the server sends rfbVncAuthFailed and 319 * closes the connection. If the server decides that too 320 * many failures have occurred, it sends rfbVncAuthTooMany 321 * and closes the connection. In the latter case, the 322 * server should not allow an immediate reconnection by 323 * the client. 324 */ 325 326 #define rfbVncAuthOK 0 327 #define rfbVncAuthFailed 1 328 #define rfbVncAuthTooMany 2 329 330 331 /*----------------------------------------------------------------------------- 332 * Client Initialisation Message 333 * 334 * Once the client and server are sure that they're happy to talk to one 335 * another, the client sends an initialisation message. At present this 336 * message only consists of a boolean indicating whether the server should try 337 * to share the desktop by leaving other clients connected, or give exclusive 338 * access to this client by disconnecting all other clients. 339 */ 340 341 typedef struct { 342 uint8_t shared; 343 } rfbClientInitMsg; 344 345 #define sz_rfbClientInitMsg 1 346 347 348 /*----------------------------------------------------------------------------- 349 * Server Initialisation Message 350 * 351 * After the client initialisation message, the server sends one of its own. 352 * This tells the client the width and height of the server's framebuffer, 353 * its pixel format and the name associated with the desktop. 354 */ 355 356 typedef struct { 357 uint16_t framebufferWidth; 358 uint16_t framebufferHeight; 359 rfbPixelFormat format; /* the server's preferred pixel format */ 360 uint32_t nameLength; 361 /* followed by char name[nameLength] */ 362 } rfbServerInitMsg; 363 364 #define sz_rfbServerInitMsg (8 + sz_rfbPixelFormat) 365 366 367 /* 368 * Following the server initialisation message it's up to the client to send 369 * whichever protocol messages it wants. Typically it will send a 370 * SetPixelFormat message and a SetEncodings message, followed by a 371 * FramebufferUpdateRequest. From then on the server will send 372 * FramebufferUpdate messages in response to the client's 373 * FramebufferUpdateRequest messages. The client should send 374 * FramebufferUpdateRequest messages with incremental set to true when it has 375 * finished processing one FramebufferUpdate and is ready to process another. 376 * With a fast client, the rate at which FramebufferUpdateRequests are sent 377 * should be regulated to avoid hogging the network. 378 */ 379 380 381 382 /***************************************************************************** 383 * 384 * Message types 385 * 386 *****************************************************************************/ 387 388 /* server -> client */ 389 390 #define rfbFramebufferUpdate 0 391 #define rfbSetColourMapEntries 1 392 #define rfbBell 2 393 #define rfbServerCutText 3 394 /* Modif sf@2002 */ 395 #define rfbResizeFrameBuffer 4 396 #define rfbPalmVNCReSizeFrameBuffer 0xF 397 398 /* client -> server */ 399 400 #define rfbSetPixelFormat 0 401 #define rfbFixColourMapEntries 1 /* not currently supported */ 402 #define rfbSetEncodings 2 403 #define rfbFramebufferUpdateRequest 3 404 #define rfbKeyEvent 4 405 #define rfbPointerEvent 5 406 #define rfbClientCutText 6 407 /* Modif sf@2002 - actually bidirectionnal */ 408 #define rfbFileTransfer 7 409 /* Modif sf@2002 */ 410 #define rfbSetScale 8 411 /* Modif rdv@2002 */ 412 #define rfbSetServerInput 9 413 /* Modif rdv@2002 */ 414 #define rfbSetSW 10 415 /* Modif sf@2002 - TextChat - Bidirectionnal */ 416 #define rfbTextChat 11 417 /* Modif cs@2005 */ 418 /* PalmVNC 1.4 & 2.0 SetScale Factor message */ 419 #define rfbPalmVNCSetScaleFactor 0xF 420 /* Xvp message - bidirectional */ 421 #define rfbXvp 250 422 423 424 425 426 /***************************************************************************** 427 * 428 * Encoding types 429 * 430 *****************************************************************************/ 431 432 #define rfbEncodingRaw 0 433 #define rfbEncodingCopyRect 1 434 #define rfbEncodingRRE 2 435 #define rfbEncodingCoRRE 4 436 #define rfbEncodingHextile 5 437 #define rfbEncodingZlib 6 438 #define rfbEncodingTight 7 439 #define rfbEncodingTightPng 0xFFFFFEFC /* -260 */ 440 #define rfbEncodingZlibHex 8 441 #define rfbEncodingUltra 9 442 #define rfbEncodingZRLE 16 443 #define rfbEncodingZYWRLE 17 444 445 /* Cache & XOR-Zlib - rdv@2002 */ 446 #define rfbEncodingCache 0xFFFF0000 447 #define rfbEncodingCacheEnable 0xFFFF0001 448 #define rfbEncodingXOR_Zlib 0xFFFF0002 449 #define rfbEncodingXORMonoColor_Zlib 0xFFFF0003 450 #define rfbEncodingXORMultiColor_Zlib 0xFFFF0004 451 #define rfbEncodingSolidColor 0xFFFF0005 452 #define rfbEncodingXOREnable 0xFFFF0006 453 #define rfbEncodingCacheZip 0xFFFF0007 454 #define rfbEncodingSolMonoZip 0xFFFF0008 455 #define rfbEncodingUltraZip 0xFFFF0009 456 457 /* Xvp pseudo-encoding */ 458 #define rfbEncodingXvp 0xFFFFFECB 459 460 /* 461 * Special encoding numbers: 462 * 0xFFFFFD00 .. 0xFFFFFD05 -- subsampling level 463 * 0xFFFFFE00 .. 0xFFFFFE64 -- fine-grained quality level (0-100 scale) 464 * 0xFFFFFF00 .. 0xFFFFFF0F -- encoding-specific compression levels; 465 * 0xFFFFFF10 .. 0xFFFFFF1F -- mouse cursor shape data; 466 * 0xFFFFFF20 .. 0xFFFFFF2F -- various protocol extensions; 467 * 0xFFFFFF30 .. 0xFFFFFFDF -- not allocated yet; 468 * 0xFFFFFFE0 .. 0xFFFFFFEF -- quality level for JPEG compressor; 469 * 0xFFFFFFF0 .. 0xFFFFFFFF -- cross-encoding compression levels. 470 */ 471 472 #define rfbEncodingFineQualityLevel0 0xFFFFFE00 473 #define rfbEncodingFineQualityLevel100 0xFFFFFE64 474 #define rfbEncodingSubsamp1X 0xFFFFFD00 475 #define rfbEncodingSubsamp4X 0xFFFFFD01 476 #define rfbEncodingSubsamp2X 0xFFFFFD02 477 #define rfbEncodingSubsampGray 0xFFFFFD03 478 #define rfbEncodingSubsamp8X 0xFFFFFD04 479 #define rfbEncodingSubsamp16X 0xFFFFFD05 480 481 #define rfbEncodingCompressLevel0 0xFFFFFF00 482 #define rfbEncodingCompressLevel1 0xFFFFFF01 483 #define rfbEncodingCompressLevel2 0xFFFFFF02 484 #define rfbEncodingCompressLevel3 0xFFFFFF03 485 #define rfbEncodingCompressLevel4 0xFFFFFF04 486 #define rfbEncodingCompressLevel5 0xFFFFFF05 487 #define rfbEncodingCompressLevel6 0xFFFFFF06 488 #define rfbEncodingCompressLevel7 0xFFFFFF07 489 #define rfbEncodingCompressLevel8 0xFFFFFF08 490 #define rfbEncodingCompressLevel9 0xFFFFFF09 491 492 #define rfbEncodingXCursor 0xFFFFFF10 493 #define rfbEncodingRichCursor 0xFFFFFF11 494 #define rfbEncodingPointerPos 0xFFFFFF18 495 496 #define rfbEncodingLastRect 0xFFFFFF20 497 #define rfbEncodingNewFBSize 0xFFFFFF21 498 499 #define rfbEncodingQualityLevel0 0xFFFFFFE0 500 #define rfbEncodingQualityLevel1 0xFFFFFFE1 501 #define rfbEncodingQualityLevel2 0xFFFFFFE2 502 #define rfbEncodingQualityLevel3 0xFFFFFFE3 503 #define rfbEncodingQualityLevel4 0xFFFFFFE4 504 #define rfbEncodingQualityLevel5 0xFFFFFFE5 505 #define rfbEncodingQualityLevel6 0xFFFFFFE6 506 #define rfbEncodingQualityLevel7 0xFFFFFFE7 507 #define rfbEncodingQualityLevel8 0xFFFFFFE8 508 #define rfbEncodingQualityLevel9 0xFFFFFFE9 509 510 511 /* LibVNCServer additions. We claim 0xFFFE0000 - 0xFFFE00FF */ 512 #define rfbEncodingKeyboardLedState 0xFFFE0000 513 #define rfbEncodingSupportedMessages 0xFFFE0001 514 #define rfbEncodingSupportedEncodings 0xFFFE0002 515 #define rfbEncodingServerIdentity 0xFFFE0003 516 517 518 /***************************************************************************** 519 * 520 * Server -> client message definitions 521 * 522 *****************************************************************************/ 523 524 525 /*----------------------------------------------------------------------------- 526 * FramebufferUpdate - a block of rectangles to be copied to the framebuffer. 527 * 528 * This message consists of a header giving the number of rectangles of pixel 529 * data followed by the rectangles themselves. The header is padded so that 530 * together with the type byte it is an exact multiple of 4 bytes (to help 531 * with alignment of 32-bit pixels): 532 */ 533 534 typedef struct { 535 uint8_t type; /* always rfbFramebufferUpdate */ 536 uint8_t pad; 537 uint16_t nRects; 538 /* followed by nRects rectangles */ 539 } rfbFramebufferUpdateMsg; 540 541 #define sz_rfbFramebufferUpdateMsg 4 542 543 /* 544 * Each rectangle of pixel data consists of a header describing the position 545 * and size of the rectangle and a type word describing the encoding of the 546 * pixel data, followed finally by the pixel data. Note that if the client has 547 * not sent a SetEncodings message then it will only receive raw pixel data. 548 * Also note again that this structure is a multiple of 4 bytes. 549 */ 550 551 typedef struct { 552 rfbRectangle r; 553 uint32_t encoding; /* one of the encoding types rfbEncoding... */ 554 } rfbFramebufferUpdateRectHeader; 555 556 #define sz_rfbFramebufferUpdateRectHeader (sz_rfbRectangle + 4) 557 558 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 559 * Supported Messages Encoding. This encoding does not contain any pixel data. 560 * Instead, it contains 2 sets of bitflags. These bitflags indicate what messages 561 * are supported by the server. 562 * rect->w contains byte count 563 */ 564 565 typedef struct { 566 uint8_t client2server[32]; /* maximum of 256 message types (256/8)=32 */ 567 uint8_t server2client[32]; /* maximum of 256 message types (256/8)=32 */ 568 } rfbSupportedMessages; 569 570 #define sz_rfbSupportedMessages 64 571 572 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 573 * Supported Encodings Encoding. This encoding does not contain any pixel data. 574 * Instead, it contains a list of (uint32_t) Encodings supported by this server. 575 * rect->w contains byte count 576 * rect->h contains encoding count 577 */ 578 579 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 580 * Server Identity Encoding. This encoding does not contain any pixel data. 581 * Instead, it contains a text string containing information about the server. 582 * ie: "x11vnc: 0.8.1 lastmod: 2006-04-25 (libvncserver 0.9pre)\0" 583 * rect->w contains byte count 584 */ 585 586 587 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 588 * Raw Encoding. Pixels are sent in top-to-bottom scanline order, 589 * left-to-right within a scanline with no padding in between. 590 */ 591 592 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 593 * KeyboardLedState Encoding. The X coordinate contains the Locked Modifiers 594 * so that a remote troubleshooter can identify that the users 'Caps Lock' 595 * is set... (It helps a *lot* when the users are untrained) 596 */ 597 #define rfbKeyboardMaskShift 1 598 #define rfbKeyboardMaskCapsLock 2 599 #define rfbKeyboardMaskControl 4 600 #define rfbKeyboardMaskAlt 8 601 #define rfbKeyboardMaskMeta 16 602 #define rfbKeyboardMaskSuper 32 603 #define rfbKeyboardMaskHyper 64 604 #define rfbKeyboardMaskNumLock 128 605 #define rfbKeyboardMaskScrollLock 256 606 #define rfbKeyboardMaskAltGraph 512 607 608 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 609 * CopyRect Encoding. The pixels are specified simply by the x and y position 610 * of the source rectangle. 611 */ 612 613 typedef struct { 614 uint16_t srcX; 615 uint16_t srcY; 616 } rfbCopyRect; 617 618 #define sz_rfbCopyRect 4 619 620 621 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 622 * RRE - Rise-and-Run-length Encoding. We have an rfbRREHeader structure 623 * giving the number of subrectangles following. Finally the data follows in 624 * the form [<bgpixel><subrect><subrect>...] where each <subrect> is 625 * [<pixel><rfbRectangle>]. 626 */ 627 628 typedef struct { 629 uint32_t nSubrects; 630 } rfbRREHeader; 631 632 #define sz_rfbRREHeader 4 633 634 635 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 636 * CoRRE - Compact RRE Encoding. We have an rfbRREHeader structure giving 637 * the number of subrectangles following. Finally the data follows in the form 638 * [<bgpixel><subrect><subrect>...] where each <subrect> is 639 * [<pixel><rfbCoRRERectangle>]. This means that 640 * the whole rectangle must be at most 255x255 pixels. 641 */ 642 643 typedef struct { 644 uint8_t x; 645 uint8_t y; 646 uint8_t w; 647 uint8_t h; 648 } rfbCoRRERectangle; 649 650 #define sz_rfbCoRRERectangle 4 651 652 653 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 654 * Hextile Encoding. The rectangle is divided up into "tiles" of 16x16 pixels, 655 * starting at the top left going in left-to-right, top-to-bottom order. If 656 * the width of the rectangle is not an exact multiple of 16 then the width of 657 * the last tile in each row will be correspondingly smaller. Similarly if the 658 * height is not an exact multiple of 16 then the height of each tile in the 659 * final row will also be smaller. Each tile begins with a "subencoding" type 660 * byte, which is a mask made up of a number of bits. If the Raw bit is set 661 * then the other bits are irrelevant; w*h pixel values follow (where w and h 662 * are the width and height of the tile). Otherwise the tile is encoded in a 663 * similar way to RRE, except that the position and size of each subrectangle 664 * can be specified in just two bytes. The other bits in the mask are as 665 * follows: 666 * 667 * BackgroundSpecified - if set, a pixel value follows which specifies 668 * the background colour for this tile. The first non-raw tile in a 669 * rectangle must have this bit set. If this bit isn't set then the 670 * background is the same as the last tile. 671 * 672 * ForegroundSpecified - if set, a pixel value follows which specifies 673 * the foreground colour to be used for all subrectangles in this tile. 674 * If this bit is set then the SubrectsColoured bit must be zero. 675 * 676 * AnySubrects - if set, a single byte follows giving the number of 677 * subrectangles following. If not set, there are no subrectangles (i.e. 678 * the whole tile is just solid background colour). 679 * 680 * SubrectsColoured - if set then each subrectangle is preceded by a pixel 681 * value giving the colour of that subrectangle. If not set, all 682 * subrectangles are the same colour, the foreground colour; if the 683 * ForegroundSpecified bit wasn't set then the foreground is the same as 684 * the last tile. 685 * 686 * The position and size of each subrectangle is specified in two bytes. The 687 * Pack macros below can be used to generate the two bytes from x, y, w, h, 688 * and the Extract macros can be used to extract the x, y, w, h values from 689 * the two bytes. 690 */ 691 692 #define rfbHextileRaw (1 << 0) 693 #define rfbHextileBackgroundSpecified (1 << 1) 694 #define rfbHextileForegroundSpecified (1 << 2) 695 #define rfbHextileAnySubrects (1 << 3) 696 #define rfbHextileSubrectsColoured (1 << 4) 697 698 #define rfbHextilePackXY(x,y) (((x) << 4) | (y)) 699 #define rfbHextilePackWH(w,h) ((((w)-1) << 4) | ((h)-1)) 700 #define rfbHextileExtractX(byte) ((byte) >> 4) 701 #define rfbHextileExtractY(byte) ((byte) & 0xf) 702 #define rfbHextileExtractW(byte) (((byte) >> 4) + 1) 703 #define rfbHextileExtractH(byte) (((byte) & 0xf) + 1) 704 705 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 706 * zlib - zlib compressed Encoding. We have an rfbZlibHeader structure 707 * giving the number of bytes following. Finally the data follows is 708 * zlib compressed version of the raw pixel data as negotiated. 709 * (NOTE: also used by Ultra Encoding) 710 */ 711 712 typedef struct { 713 uint32_t nBytes; 714 } rfbZlibHeader; 715 716 #define sz_rfbZlibHeader 4 717 718 #ifdef LIBVNCSERVER_HAVE_LIBZ 719 720 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 721 * Tight and TightPng Encoding. 722 * 723 *-- TightPng is like Tight but basic compression is not used, instead PNG 724 * data is sent. 725 * 726 *-- The first byte of each Tight-encoded rectangle is a "compression control 727 * byte". Its format is as follows (bit 0 is the least significant one): 728 * 729 * bit 0: if 1, then compression stream 0 should be reset; 730 * bit 1: if 1, then compression stream 1 should be reset; 731 * bit 2: if 1, then compression stream 2 should be reset; 732 * bit 3: if 1, then compression stream 3 should be reset; 733 * bits 7-4: if 1000 (0x08), then the compression type is "fill", 734 * if 1001 (0x09), then the compression type is "jpeg", 735 * (Tight only) if 1010 (0x0A), then the compression type is 736 * "basic" and no Zlib compression was used, 737 * (Tight only) if 1110 (0x0E), then the compression type is 738 * "basic", no Zlib compression was used, and a "filter id" byte 739 * follows this byte, 740 * (TightPng only) if 1010 (0x0A), then the compression type is 741 * "png", 742 * if 0xxx, then the compression type is "basic" and Zlib 743 * compression was used, 744 * values greater than 1010 are not valid. 745 * 746 * If the compression type is "basic" and Zlib compression was used, then bits 747 * 6..4 of the compression control byte (those xxx in 0xxx) specify the 748 * following: 749 * 750 * bits 5-4: decimal representation is the index of a particular zlib 751 * stream which should be used for decompressing the data; 752 * bit 6: if 1, then a "filter id" byte is following this byte. 753 * 754 *-- The data that follows after the compression control byte described 755 * above depends on the compression type ("fill", "jpeg", "png" or "basic"). 756 * 757 *-- If the compression type is "fill", then the only pixel value follows, in 758 * client pixel format (see NOTE 1). This value applies to all pixels of the 759 * rectangle. 760 * 761 *-- If the compression type is "jpeg" or "png", the following data stream 762 * looks like this: 763 * 764 * 1..3 bytes: data size (N) in compact representation; 765 * N bytes: JPEG or PNG image. 766 * 767 * Data size is compactly represented in one, two or three bytes, according 768 * to the following scheme: 769 * 770 * 0xxxxxxx (for values 0..127) 771 * 1xxxxxxx 0yyyyyyy (for values 128..16383) 772 * 1xxxxxxx 1yyyyyyy zzzzzzzz (for values 16384..4194303) 773 * 774 * Here each character denotes one bit, xxxxxxx are the least significant 7 775 * bits of the value (bits 0-6), yyyyyyy are bits 7-13, and zzzzzzzz are the 776 * most significant 8 bits (bits 14-21). For example, decimal value 10000 777 * should be represented as two bytes: binary 10010000 01001110, or 778 * hexadecimal 90 4E. 779 * 780 *-- If the compression type is "basic" and bit 6 of the compression control 781 * byte was set to 1, then the next (second) byte specifies "filter id" which 782 * tells the decoder what filter type was used by the encoder to pre-process 783 * pixel data before the compression. The "filter id" byte can be one of the 784 * following: 785 * 786 * 0: no filter ("copy" filter); 787 * 1: "palette" filter; 788 * 2: "gradient" filter. 789 * 790 *-- If bit 6 of the compression control byte is set to 0 (no "filter id" 791 * byte), or if the filter id is 0, then raw pixel values in the client 792 * format (see NOTE 1) will be compressed. See below details on the 793 * compression. 794 * 795 *-- The "gradient" filter pre-processes pixel data with a simple algorithm 796 * which converts each color component to a difference between a "predicted" 797 * intensity and the actual intensity. Such a technique does not affect 798 * uncompressed data size, but helps to compress photo-like images better. 799 * Pseudo-code for converting intensities to differences is the following: 800 * 801 * P[i,j] := V[i-1,j] + V[i,j-1] - V[i-1,j-1]; 802 * if (P[i,j] < 0) then P[i,j] := 0; 803 * if (P[i,j] > MAX) then P[i,j] := MAX; 804 * D[i,j] := V[i,j] - P[i,j]; 805 * 806 * Here V[i,j] is the intensity of a color component for a pixel at 807 * coordinates (i,j). MAX is the maximum value of intensity for a color 808 * component. 809 * 810 *-- The "palette" filter converts true-color pixel data to indexed colors 811 * and a palette which can consist of 2..256 colors. If the number of colors 812 * is 2, then each pixel is encoded in 1 bit, otherwise 8 bits is used to 813 * encode one pixel. 1-bit encoding is performed such way that the most 814 * significant bits correspond to the leftmost pixels, and each raw of pixels 815 * is aligned to the byte boundary. When "palette" filter is used, the 816 * palette is sent before the pixel data. The palette begins with an unsigned 817 * byte which value is the number of colors in the palette minus 1 (i.e. 1 818 * means 2 colors, 255 means 256 colors in the palette). Then follows the 819 * palette itself which consist of pixel values in client pixel format (see 820 * NOTE 1). 821 * 822 *-- The pixel data is compressed using the zlib library. But if the data 823 * size after applying the filter but before the compression is less then 12, 824 * then the data is sent as is, uncompressed. Four separate zlib streams 825 * (0..3) can be used and the decoder should read the actual stream id from 826 * the compression control byte (see NOTE 2). 827 * 828 * If the compression is not used, then the pixel data is sent as is, 829 * otherwise the data stream looks like this: 830 * 831 * 1..3 bytes: data size (N) in compact representation; 832 * N bytes: zlib-compressed data. 833 * 834 * Data size is compactly represented in one, two or three bytes, just like 835 * in the "jpeg" compression method (see above). 836 * 837 *-- NOTE 1. If the color depth is 24, and all three color components are 838 * 8-bit wide, then one pixel in Tight encoding is always represented by 839 * three bytes, where the first byte is red component, the second byte is 840 * green component, and the third byte is blue component of the pixel color 841 * value. This applies to colors in palettes as well. 842 * 843 *-- NOTE 2. The decoder must reset compression streams' states before 844 * decoding the rectangle, if some of bits 0,1,2,3 in the compression control 845 * byte are set to 1. Note that the decoder must reset zlib streams even if 846 * the compression type is "fill", "jpeg" or "png". 847 * 848 *-- NOTE 3. The "gradient" filter and "jpeg" compression may be used only 849 * when bits-per-pixel value is either 16 or 32, not 8. 850 * 851 *-- NOTE 4. The width of any Tight-encoded rectangle cannot exceed 2048 852 * pixels. If a rectangle is wider, it must be split into several rectangles 853 * and each one should be encoded separately. 854 * 855 */ 856 857 #define rfbTightExplicitFilter 0x04 858 #define rfbTightFill 0x08 859 #define rfbTightJpeg 0x09 860 #define rfbTightNoZlib 0x0A 861 #define rfbTightPng 0x0A 862 #define rfbTightMaxSubencoding 0x0A 863 864 /* Filters to improve compression efficiency */ 865 #define rfbTightFilterCopy 0x00 866 #define rfbTightFilterPalette 0x01 867 #define rfbTightFilterGradient 0x02 868 869 #endif 870 871 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 872 * XCursor encoding. This is a special encoding used to transmit X-style 873 * cursor shapes from server to clients. Note that for this encoding, 874 * coordinates in rfbFramebufferUpdateRectHeader structure hold hotspot 875 * position (r.x, r.y) and cursor size (r.w, r.h). If (w * h != 0), two RGB 876 * samples are sent after header in the rfbXCursorColors structure. They 877 * denote foreground and background colors of the cursor. If a client 878 * supports only black-and-white cursors, it should ignore these colors and 879 * assume that foreground is black and background is white. Next, two bitmaps 880 * (1 bits per pixel) follow: first one with actual data (value 0 denotes 881 * background color, value 1 denotes foreground color), second one with 882 * transparency data (bits with zero value mean that these pixels are 883 * transparent). Both bitmaps represent cursor data in a byte stream, from 884 * left to right, from top to bottom, and each row is byte-aligned. Most 885 * significant bits correspond to leftmost pixels. The number of bytes in 886 * each row can be calculated as ((w + 7) / 8). If (w * h == 0), cursor 887 * should be hidden (or default local cursor should be set by the client). 888 */ 889 890 typedef struct { 891 uint8_t foreRed; 892 uint8_t foreGreen; 893 uint8_t foreBlue; 894 uint8_t backRed; 895 uint8_t backGreen; 896 uint8_t backBlue; 897 } rfbXCursorColors; 898 899 #define sz_rfbXCursorColors 6 900 901 902 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 903 * RichCursor encoding. This is a special encoding used to transmit cursor 904 * shapes from server to clients. It is similar to the XCursor encoding but 905 * uses client pixel format instead of two RGB colors to represent cursor 906 * image. For this encoding, coordinates in rfbFramebufferUpdateRectHeader 907 * structure hold hotspot position (r.x, r.y) and cursor size (r.w, r.h). 908 * After header, two pixmaps follow: first one with cursor image in current 909 * client pixel format (like in raw encoding), second with transparency data 910 * (1 bit per pixel, exactly the same format as used for transparency bitmap 911 * in the XCursor encoding). If (w * h == 0), cursor should be hidden (or 912 * default local cursor should be set by the client). 913 */ 914 915 916 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 917 * ZRLE - encoding combining Zlib compression, tiling, palettisation and 918 * run-length encoding. 919 */ 920 921 typedef struct { 922 uint32_t length; 923 } rfbZRLEHeader; 924 925 #define sz_rfbZRLEHeader 4 926 927 #define rfbZRLETileWidth 64 928 #define rfbZRLETileHeight 64 929 930 931 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 932 * ZLIBHEX - zlib compressed Hextile Encoding. Essentially, this is the 933 * hextile encoding with zlib compression on the tiles that can not be 934 * efficiently encoded with one of the other hextile subencodings. The 935 * new zlib subencoding uses two bytes to specify the length of the 936 * compressed tile and then the compressed data follows. As with the 937 * raw sub-encoding, the zlib subencoding invalidates the other 938 * values, if they are also set. 939 */ 940 941 #define rfbHextileZlibRaw (1 << 5) 942 #define rfbHextileZlibHex (1 << 6) 943 #define rfbHextileZlibMono (1 << 7) 944 945 946 /*----------------------------------------------------------------------------- 947 * SetColourMapEntries - these messages are only sent if the pixel 948 * format uses a "colour map" (i.e. trueColour false) and the client has not 949 * fixed the entire colour map using FixColourMapEntries. In addition they 950 * will only start being sent after the client has sent its first 951 * FramebufferUpdateRequest. So if the client always tells the server to use 952 * trueColour then it never needs to process this type of message. 953 */ 954 955 typedef struct { 956 uint8_t type; /* always rfbSetColourMapEntries */ 957 uint8_t pad; 958 uint16_t firstColour; 959 uint16_t nColours; 960 961 /* Followed by nColours * 3 * uint16_t 962 r1, g1, b1, r2, g2, b2, r3, g3, b3, ..., rn, bn, gn */ 963 964 } rfbSetColourMapEntriesMsg; 965 966 #define sz_rfbSetColourMapEntriesMsg 6 967 968 969 970 /*----------------------------------------------------------------------------- 971 * Bell - ring a bell on the client if it has one. 972 */ 973 974 typedef struct { 975 uint8_t type; /* always rfbBell */ 976 } rfbBellMsg; 977 978 #define sz_rfbBellMsg 1 979 980 981 982 /*----------------------------------------------------------------------------- 983 * ServerCutText - the server has new text in its cut buffer. 984 */ 985 986 typedef struct { 987 uint8_t type; /* always rfbServerCutText */ 988 uint8_t pad1; 989 uint16_t pad2; 990 uint32_t length; 991 /* followed by char text[length] */ 992 } rfbServerCutTextMsg; 993 994 #define sz_rfbServerCutTextMsg 8 995 996 997 /*----------------------------------------------------------------------------- 998 * // Modif sf@2002 999 * FileTransferMsg - The client sends FileTransfer message. 1000 * Bidirectional message - Files can be sent from client to server & vice versa 1001 */ 1002 1003 typedef struct _rfbFileTransferMsg { 1004 uint8_t type; /* always rfbFileTransfer */ 1005 uint8_t contentType; /* See defines below */ 1006 uint8_t contentParam;/* Other possible content classification (Dir or File name, etc..) */ 1007 uint8_t pad; /* It appears that UltraVNC *forgot* to Swap16IfLE(contentParam) */ 1008 uint32_t size; /* FileSize or packet index or error or other */ 1009 /* uint32_t sizeH; Additional 32Bits params to handle big values. Only for V2 (we want backward compatibility between all V1 versions) */ 1010 uint32_t length; 1011 /* followed by data char text[length] */ 1012 } rfbFileTransferMsg; 1013 1014 #define sz_rfbFileTransferMsg 12 1015 1016 #define rfbFileTransferVersion 2 /* v1 is the old FT version ( <= 1.0.0 RC18 versions) */ 1017 1018 /* FileTransfer Content types and Params defines */ 1019 #define rfbDirContentRequest 1 /* Client asks for the content of a given Server directory */ 1020 #define rfbDirPacket 2 /* Full directory name or full file name. */ 1021 /* Null content means end of Directory */ 1022 #define rfbFileTransferRequest 3 /* Client asks the server for the transfer of a given file */ 1023 #define rfbFileHeader 4 /* First packet of a file transfer, containing file's features */ 1024 #define rfbFilePacket 5 /* One chunk of the file */ 1025 #define rfbEndOfFile 6 /* End of file transfer (the file has been received or error) */ 1026 #define rfbAbortFileTransfer 7 /* The file transfer must be aborted, whatever the state */ 1027 #define rfbFileTransferOffer 8 /* The client offers to send a file to the server */ 1028 #define rfbFileAcceptHeader 9 /* The server accepts or rejects the file */ 1029 #define rfbCommand 10 /* The Client sends a simple command (File Delete, Dir create etc...) */ 1030 #define rfbCommandReturn 11 /* The Client receives the server's answer about a simple command */ 1031 #define rfbFileChecksums 12 /* The zipped checksums of the destination file (Delta Transfer) */ 1032 #define rfbFileTransferAccess 14 /* Request FileTransfer authorization */ 1033 1034 /* rfbDirContentRequest client Request - content params */ 1035 #define rfbRDirContent 1 /* Request a Server Directory contents */ 1036 #define rfbRDrivesList 2 /* Request the server's drives list */ 1037 #define rfbRDirRecursiveList 3 /* Request a server directory content recursive sorted list */ 1038 #define rfbRDirRecursiveSize 4 /* Request a server directory content recursive size */ 1039 1040 /* rfbDirPacket & rfbCommandReturn server Answer - content params */ 1041 #define rfbADirectory 1 /* Reception of a directory name */ 1042 #define rfbAFile 2 /* Reception of a file name */ 1043 #define rfbADrivesList 3 /* Reception of a list of drives */ 1044 #define rfbADirCreate 4 /* Response to a create dir command */ 1045 #define rfbADirDelete 5 /* Response to a delete dir command */ 1046 #define rfbAFileCreate 6 /* Response to a create file command */ 1047 #define rfbAFileDelete 7 /* Response to a delete file command */ 1048 #define rfbAFileRename 8 /* Response to a rename file command */ 1049 #define rfbADirRename 9 /* Response to a rename dir command */ 1050 #define rfbADirRecursiveListItem 10 1051 #define rfbADirRecursiveSize 11 1052 1053 /* rfbCommand Command - content params */ 1054 #define rfbCDirCreate 1 /* Request the server to create the given directory */ 1055 #define rfbCDirDelete 2 /* Request the server to delete the given directory */ 1056 #define rfbCFileCreate 3 /* Request the server to create the given file */ 1057 #define rfbCFileDelete 4 /* Request the server to delete the given file */ 1058 #define rfbCFileRename 5 /* Request the server to rename the given file */ 1059 #define rfbCDirRename 6 /* Request the server to rename the given directory */ 1060 1061 /* Errors - content params or "size" field */ 1062 #define rfbRErrorUnknownCmd 1 /* Unknown FileTransfer command. */ 1063 #define rfbRErrorCmd 0xFFFFFFFF/* Error when a command fails on remote side (ret in "size" field) */ 1064 1065 #define sz_rfbBlockSize 8192 /* Size of a File Transfer packet (before compression) */ 1066 #define rfbZipDirectoryPrefix "!UVNCDIR-\0" /* Transfered directory are zipped in a file with this prefix. Must end with "-" */ 1067 #define sz_rfbZipDirectoryPrefix 9 1068 #define rfbDirPrefix "[ " 1069 #define rfbDirSuffix " ]" 1070 1071 1072 1073 /*----------------------------------------------------------------------------- 1074 * Modif sf@2002 1075 * TextChatMsg - Utilized to order the TextChat mode on server or client 1076 * Bidirectional message 1077 */ 1078 1079 typedef struct _rfbTextChatMsg { 1080 uint8_t type; /* always rfbTextChat */ 1081 uint8_t pad1; /* Could be used later as an additionnal param */ 1082 uint16_t pad2; /* Could be used later as text offset, for instance */ 1083 uint32_t length; /* Specific values for Open, close, finished (-1, -2, -3) */ 1084 /* followed by char text[length] */ 1085 } rfbTextChatMsg; 1086 1087 #define sz_rfbTextChatMsg 8 1088 1089 #define rfbTextMaxSize 4096 1090 #define rfbTextChatOpen 0xFFFFFFFF 1091 #define rfbTextChatClose 0xFFFFFFFE 1092 #define rfbTextChatFinished 0xFFFFFFFD 1093 1094 1095 /*----------------------------------------------------------------------------- 1096 * Xvp Message 1097 * Bidirectional message 1098 * A server which supports the xvp extension declares this by sending a message 1099 * with an Xvp_INIT xvp-message-code when it receives a request from the client 1100 * to use the xvp Pseudo-encoding. The server must specify in this message the 1101 * highest xvp-extension-version it supports: the client may assume that the 1102 * server supports all versions from 1 up to this value. The client is then 1103 * free to use any supported version. Currently, only version 1 is defined. 1104 * 1105 * A server which subsequently receives an xvp Client Message requesting an 1106 * operation which it is unable to perform, informs the client of this by 1107 * sending a message with an Xvp_FAIL xvp-message-code, and the same 1108 * xvp-extension-version as included in the client's operation request. 1109 * 1110 * A client supporting the xvp extension sends this to request that the server 1111 * initiate a clean shutdown, clean reboot or abrupt reset of the system whose 1112 * framebuffer the client is displaying. 1113 */ 1114 1115 1116 typedef struct { 1117 uint8_t type; /* always rfbXvp */ 1118 uint8_t pad; 1119 uint8_t version; /* xvp extension version */ 1120 uint8_t code; /* xvp message code */ 1121 } rfbXvpMsg; 1122 1123 #define sz_rfbXvpMsg (4) 1124 1125 /* server message codes */ 1126 #define rfbXvp_Fail 0 1127 #define rfbXvp_Init 1 1128 /* client message codes */ 1129 #define rfbXvp_Shutdown 2 1130 #define rfbXvp_Reboot 3 1131 #define rfbXvp_Reset 4 1132 1133 1134 /*----------------------------------------------------------------------------- 1135 * Modif sf@2002 1136 * ResizeFrameBuffer - The Client must change the size of its framebuffer 1137 */ 1138 1139 typedef struct _rfbResizeFrameBufferMsg { 1140 uint8_t type; /* always rfbResizeFrameBuffer */ 1141 uint8_t pad1; 1142 uint16_t framebufferWidth; /* FrameBuffer width */ 1143 uint16_t framebufferHeigth; /* FrameBuffer height */ 1144 } rfbResizeFrameBufferMsg; 1145 1146 #define sz_rfbResizeFrameBufferMsg 6 1147 1148 1149 /*----------------------------------------------------------------------------- 1150 * Copyright (C) 2001 Harakan Software 1151 * PalmVNC 1.4 & 2.? ResizeFrameBuffer message 1152 * ReSizeFrameBuffer - tell the RFB client to alter its framebuffer, either 1153 * due to a resize of the server desktop or a client-requested scaling factor. 1154 * The pixel format remains unchanged. 1155 */ 1156 1157 typedef struct { 1158 uint8_t type; /* always rfbReSizeFrameBuffer */ 1159 uint8_t pad1; 1160 uint16_t desktop_w; /* Desktop width */ 1161 uint16_t desktop_h; /* Desktop height */ 1162 uint16_t buffer_w; /* FrameBuffer width */ 1163 uint16_t buffer_h; /* Framebuffer height */ 1164 uint16_t pad2; 1165 1166 } rfbPalmVNCReSizeFrameBufferMsg; 1167 1168 #define sz_rfbPalmVNCReSizeFrameBufferMsg (12) 1169 1170 1171 1172 1173 /*----------------------------------------------------------------------------- 1174 * Union of all server->client messages. 1175 */ 1176 1177 typedef union { 1178 uint8_t type; 1179 rfbFramebufferUpdateMsg fu; 1180 rfbSetColourMapEntriesMsg scme; 1181 rfbBellMsg b; 1182 rfbServerCutTextMsg sct; 1183 rfbResizeFrameBufferMsg rsfb; 1184 rfbPalmVNCReSizeFrameBufferMsg prsfb; 1185 rfbFileTransferMsg ft; 1186 rfbTextChatMsg tc; 1187 rfbXvpMsg xvp; 1188 } rfbServerToClientMsg; 1189 1190 1191 1192 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1193 * RDV Cache Encoding. 1194 * special is not used at this point, can be used to reset cache or other specials 1195 * just put it to make sure we don't have to change the encoding again. 1196 */ 1197 1198 typedef struct { 1199 uint16_t special; 1200 } rfbCacheRect; 1201 1202 #define sz_rfbCacheRect 2 1203 1204 1205 1206 1207 /***************************************************************************** 1208 * 1209 * Message definitions (client -> server) 1210 * 1211 *****************************************************************************/ 1212 1213 1214 /*----------------------------------------------------------------------------- 1215 * SetPixelFormat - tell the RFB server the format in which the client wants 1216 * pixels sent. 1217 */ 1218 1219 typedef struct { 1220 uint8_t type; /* always rfbSetPixelFormat */ 1221 uint8_t pad1; 1222 uint16_t pad2; 1223 rfbPixelFormat format; 1224 } rfbSetPixelFormatMsg; 1225 1226 #define sz_rfbSetPixelFormatMsg (sz_rfbPixelFormat + 4) 1227 1228 1229 /*----------------------------------------------------------------------------- 1230 * FixColourMapEntries - when the pixel format uses a "colour map", fix 1231 * read-only colour map entries. 1232 * 1233 * ***************** NOT CURRENTLY SUPPORTED ***************** 1234 */ 1235 1236 typedef struct { 1237 uint8_t type; /* always rfbFixColourMapEntries */ 1238 uint8_t pad; 1239 uint16_t firstColour; 1240 uint16_t nColours; 1241 1242 /* Followed by nColours * 3 * uint16_t 1243 r1, g1, b1, r2, g2, b2, r3, g3, b3, ..., rn, bn, gn */ 1244 1245 } rfbFixColourMapEntriesMsg; 1246 1247 #define sz_rfbFixColourMapEntriesMsg 6 1248 1249 1250 /*----------------------------------------------------------------------------- 1251 * SetEncodings - tell the RFB server which encoding types we accept. Put them 1252 * in order of preference, if we have any. We may always receive raw 1253 * encoding, even if we don't specify it here. 1254 */ 1255 1256 typedef struct { 1257 uint8_t type; /* always rfbSetEncodings */ 1258 uint8_t pad; 1259 uint16_t nEncodings; 1260 /* followed by nEncodings * uint32_t encoding types */ 1261 } rfbSetEncodingsMsg; 1262 1263 #define sz_rfbSetEncodingsMsg 4 1264 1265 1266 /*----------------------------------------------------------------------------- 1267 * FramebufferUpdateRequest - request for a framebuffer update. If incremental 1268 * is true then the client just wants the changes since the last update. If 1269 * false then it wants the whole of the specified rectangle. 1270 */ 1271 1272 typedef struct { 1273 uint8_t type; /* always rfbFramebufferUpdateRequest */ 1274 uint8_t incremental; 1275 uint16_t x; 1276 uint16_t y; 1277 uint16_t w; 1278 uint16_t h; 1279 } rfbFramebufferUpdateRequestMsg; 1280 1281 #define sz_rfbFramebufferUpdateRequestMsg 10 1282 1283 1284 /*----------------------------------------------------------------------------- 1285 * KeyEvent - key press or release 1286 * 1287 * Keys are specified using the "keysym" values defined by the X Window System. 1288 * For most ordinary keys, the keysym is the same as the corresponding ASCII 1289 * value. Other common keys are: 1290 * 1291 * BackSpace 0xff08 1292 * Tab 0xff09 1293 * Return or Enter 0xff0d 1294 * Escape 0xff1b 1295 * Insert 0xff63 1296 * Delete 0xffff 1297 * Home 0xff50 1298 * End 0xff57 1299 * Page Up 0xff55 1300 * Page Down 0xff56 1301 * Left 0xff51 1302 * Up 0xff52 1303 * Right 0xff53 1304 * Down 0xff54 1305 * F1 0xffbe 1306 * F2 0xffbf 1307 * ... ... 1308 * F12 0xffc9 1309 * Shift 0xffe1 1310 * Control 0xffe3 1311 * Meta 0xffe7 1312 * Alt 0xffe9 1313 */ 1314 1315 typedef struct { 1316 uint8_t type; /* always rfbKeyEvent */ 1317 uint8_t down; /* true if down (press), false if up */ 1318 uint16_t pad; 1319 uint32_t key; /* key is specified as an X keysym */ 1320 } rfbKeyEventMsg; 1321 1322 #define sz_rfbKeyEventMsg 8 1323 1324 1325 /*----------------------------------------------------------------------------- 1326 * PointerEvent - mouse/pen move and/or button press. 1327 */ 1328 1329 typedef struct { 1330 uint8_t type; /* always rfbPointerEvent */ 1331 uint8_t buttonMask; /* bits 0-7 are buttons 1-8, 0=up, 1=down */ 1332 uint16_t x; 1333 uint16_t y; 1334 } rfbPointerEventMsg; 1335 1336 #define rfbButton1Mask 1 1337 #define rfbButton2Mask 2 1338 #define rfbButton3Mask 4 1339 #define rfbButton4Mask 8 1340 #define rfbButton5Mask 16 1341 /* RealVNC 335 method */ 1342 #define rfbWheelUpMask rfbButton4Mask 1343 #define rfbWheelDownMask rfbButton5Mask 1344 1345 #define sz_rfbPointerEventMsg 6 1346 1347 1348 1349 /*----------------------------------------------------------------------------- 1350 * ClientCutText - the client has new text in its cut buffer. 1351 */ 1352 1353 typedef struct { 1354 uint8_t type; /* always rfbClientCutText */ 1355 uint8_t pad1; 1356 uint16_t pad2; 1357 uint32_t length; 1358 /* followed by char text[length] */ 1359 } rfbClientCutTextMsg; 1360 1361 #define sz_rfbClientCutTextMsg 8 1362 1363 1364 1365 /*----------------------------------------------------------------------------- 1366 * sf@2002 - Set Server Scale 1367 * SetServerScale - Server must change the scale of the client buffer. 1368 */ 1369 1370 typedef struct _rfbSetScaleMsg { 1371 uint8_t type; /* always rfbSetScale */ 1372 uint8_t scale; /* Scale value 1<sv<n */ 1373 uint16_t pad; 1374 } rfbSetScaleMsg; 1375 1376 #define sz_rfbSetScaleMsg 4 1377 1378 1379 /*----------------------------------------------------------------------------- 1380 * Copyright (C) 2001 Harakan Software 1381 * PalmVNC 1.4 & 2.? SetScale Factor message 1382 * SetScaleFactor - tell the RFB server to alter the scale factor for the 1383 * client buffer. 1384 */ 1385 typedef struct { 1386 uint8_t type; /* always rfbPalmVNCSetScaleFactor */ 1387 1388 uint8_t scale; /* Scale factor (positive non-zero integer) */ 1389 uint16_t pad2; 1390 } rfbPalmVNCSetScaleFactorMsg; 1391 1392 #define sz_rfbPalmVNCSetScaleFactorMsg (4) 1393 1394 1395 /*----------------------------------------------------------------------------- 1396 * rdv@2002 - Set input status 1397 * SetServerInput - Server input is dis/enabled 1398 */ 1399 1400 typedef struct _rfbSetServerInputMsg { 1401 uint8_t type; /* always rfbSetScale */ 1402 uint8_t status; /* Scale value 1<sv<n */ 1403 uint16_t pad; 1404 } rfbSetServerInputMsg; 1405 1406 #define sz_rfbSetServerInputMsg 4 1407 1408 /*----------------------------------------------------------------------------- 1409 * rdv@2002 - Set SW 1410 * SetSW - Server SW/full desktop 1411 */ 1412 1413 typedef struct _rfbSetSWMsg { 1414 uint8_t type; /* always rfbSetSW */ 1415 uint8_t status; 1416 uint16_t x; 1417 uint16_t y; 1418 } rfbSetSWMsg; 1419 1420 #define sz_rfbSetSWMsg 6 1421 1422 1423 1424 /*----------------------------------------------------------------------------- 1425 * Union of all client->server messages. 1426 */ 1427 1428 typedef union { 1429 uint8_t type; 1430 rfbSetPixelFormatMsg spf; 1431 rfbFixColourMapEntriesMsg fcme; 1432 rfbSetEncodingsMsg se; 1433 rfbFramebufferUpdateRequestMsg fur; 1434 rfbKeyEventMsg ke; 1435 rfbPointerEventMsg pe; 1436 rfbClientCutTextMsg cct; 1437 rfbSetScaleMsg ssc; 1438 rfbPalmVNCSetScaleFactorMsg pssf; 1439 rfbSetServerInputMsg sim; 1440 rfbFileTransferMsg ft; 1441 rfbSetSWMsg sw; 1442 rfbTextChatMsg tc; 1443 rfbXvpMsg xvp; 1444 } rfbClientToServerMsg; 1445 1446 /* 1447 * vncauth.h - describes the functions provided by the vncauth library. 1448 */ 1449 1450 #define MAXPWLEN 8 1451 #define CHALLENGESIZE 16 1452 1453 extern int rfbEncryptAndStorePasswd(char *passwd, char *fname); 1454 extern char *rfbDecryptPasswdFromFile(char *fname); 1455 extern void rfbRandomBytes(unsigned char *bytes); 1456 extern void rfbEncryptBytes(unsigned char *bytes, char *passwd); 1457 1458 1459 #endif 1460
