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