2
* Copyright (C) 2000-2002 Constantin Kaplinsky. All Rights Reserved.
3
* Copyright (C) 2000 Tridia Corporation. All Rights Reserved.
4
* Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved.
6
* This is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; either version 2 of the License, or
9
* (at your option) any later version.
11
* This software is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
* GNU General Public License for more details.
16
* You should have received a copy of the GNU General Public License
17
* along with this software; if not, write to the Free Software
18
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
23
* rfbproto.h - header file for the RFB protocol version 3.3
25
* Uses types CARD<n> for an n-bit unsigned integer, INT<n> for an n-bit signed
26
* integer (for n = 8, 16 and 32).
28
* All multiple byte integers are in big endian (network) order (most
29
* significant byte first). Unless noted otherwise there is no special
30
* alignment of protocol structures.
33
* Once the initial handshaking is done, all messages start with a type byte,
34
* (usually) followed by message-specific data. The order of definitions in
35
* this file is as follows:
37
* (1) Structures used in several types of message.
38
* (2) Structures used in the initial handshaking.
41
* (5) For each message type, the form of the data following the type byte.
42
* Sometimes this is defined by a single structure but the more complex
43
* messages have to be explained by comments.
47
/*****************************************************************************
49
* Structures used in several messages
51
*****************************************************************************/
53
/*-----------------------------------------------------------------------------
54
* Structure used to specify a rectangle. This structure is a multiple of 4
55
* bytes so that it can be interspersed with 32-bit pixel data without
56
* affecting alignment.
66
#define sz_rfbRectangle 8
69
/*-----------------------------------------------------------------------------
70
* Structure used to specify pixel format.
75
CARD8 bitsPerPixel; /* 8,16,32 only */
77
CARD8 depth; /* 8 to 32 */
79
CARD8 bigEndian; /* True if multi-byte pixels are interpreted
80
as big endian, or if single-bit-per-pixel
81
has most significant bit of the byte
82
corresponding to first (leftmost) pixel. Of
83
course this is meaningless for 8 bits/pix */
85
CARD8 trueColour; /* If false then we need a "colour map" to
86
convert pixels to RGB. If true, xxxMax and
87
xxxShift specify bits used for red, green
90
/* the following fields are only meaningful if trueColour is true */
92
CARD16 redMax; /* maximum red value (= 2^n - 1 where n is the
93
number of bits used for red). Note this
94
value is always in big endian order. */
96
CARD16 greenMax; /* similar for green */
98
CARD16 blueMax; /* and blue */
100
CARD8 redShift; /* number of shifts needed to get the red
101
value in a pixel to the least significant
102
bit. To find the red value from a given
103
pixel, do the following:
104
1) Swap pixel value according to bigEndian
105
(e.g. if bigEndian is false and host byte
106
order is big endian, then swap).
107
2) Shift right by redShift.
108
3) AND with redMax (in host byte order).
109
4) You now have the red value between 0 and
112
CARD8 greenShift; /* similar for green */
114
CARD8 blueShift; /* and blue */
121
#define sz_rfbPixelFormat 16
125
/*****************************************************************************
127
* Initial handshaking messages
129
*****************************************************************************/
131
/*-----------------------------------------------------------------------------
134
* The server always sends 12 bytes to start which identifies the latest RFB
135
* protocol version number which it supports. These bytes are interpreted
136
* as a string of 12 ASCII characters in the format "RFB xxx.yyy\n" where
137
* xxx and yyy are the major and minor version numbers (for version 3.3
138
* this is "RFB 003.003\n").
140
* The client then replies with a similar 12-byte message giving the version
141
* number of the protocol which should actually be used (which may be different
142
* to that quoted by the server).
144
* It is intended that both clients and servers may provide some level of
145
* backwards compatibility by this mechanism. Servers in particular should
146
* attempt to provide backwards compatibility, and even forwards compatibility
147
* to some extent. For example if a client demands version 3.1 of the
148
* protocol, a 3.0 server can probably assume that by ignoring requests for
149
* encoding types it doesn't understand, everything will still work OK. This
150
* will probably not be the case for changes in the major version number.
152
* The format string below can be used in sprintf or sscanf to generate or
153
* decode the version string respectively.
156
#define rfbProtocolVersionFormat "RFB %03d.%03d\n"
157
#define rfbProtocolMajorVersion 3
158
#define rfbProtocolMinorVersion 3
160
typedef char rfbProtocolVersionMsg[13]; /* allow extra byte for null */
162
#define sz_rfbProtocolVersionMsg 12
165
/*-----------------------------------------------------------------------------
168
* Once the protocol version has been decided, the server then sends a 32-bit
169
* word indicating whether any authentication is needed on the connection.
170
* The value of this word determines the authentication scheme in use. For
171
* version 3.0 of the protocol this may have one of the following values:
174
#define rfbConnFailed 0
179
* rfbConnFailed: For some reason the connection failed (e.g. the server
180
* cannot support the desired protocol version). This is
181
* followed by a string describing the reason (where a
182
* string is specified as a 32-bit length followed by that
183
* many ASCII characters).
185
* rfbNoAuth: No authentication is needed.
187
* rfbVncAuth: The VNC authentication scheme is to be used. A 16-byte
188
* challenge follows, which the client encrypts as
189
* appropriate using the password and sends the resulting
190
* 16-byte response. If the response is correct, the
191
* server sends the 32-bit word rfbVncAuthOK. If a simple
192
* failure happens, the server sends rfbVncAuthFailed and
193
* closes the connection. If the server decides that too
194
* many failures have occurred, it sends rfbVncAuthTooMany
195
* and closes the connection. In the latter case, the
196
* server should not allow an immediate reconnection by
200
#define rfbVncAuthOK 0
201
#define rfbVncAuthFailed 1
202
#define rfbVncAuthTooMany 2
205
/*-----------------------------------------------------------------------------
206
* Client Initialisation Message
208
* Once the client and server are sure that they're happy to talk to one
209
* another, the client sends an initialisation message. At present this
210
* message only consists of a boolean indicating whether the server should try
211
* to share the desktop by leaving other clients connected, or give exclusive
212
* access to this client by disconnecting all other clients.
219
#define sz_rfbClientInitMsg 1
222
/*-----------------------------------------------------------------------------
223
* Server Initialisation Message
225
* After the client initialisation message, the server sends one of its own.
226
* This tells the client the width and height of the server's framebuffer,
227
* its pixel format and the name associated with the desktop.
231
CARD16 framebufferWidth;
232
CARD16 framebufferHeight;
233
rfbPixelFormat format; /* the server's preferred pixel format */
235
/* followed by char name[nameLength] */
238
#define sz_rfbServerInitMsg (8 + sz_rfbPixelFormat)
242
* Following the server initialisation message it's up to the client to send
243
* whichever protocol messages it wants. Typically it will send a
244
* SetPixelFormat message and a SetEncodings message, followed by a
245
* FramebufferUpdateRequest. From then on the server will send
246
* FramebufferUpdate messages in response to the client's
247
* FramebufferUpdateRequest messages. The client should send
248
* FramebufferUpdateRequest messages with incremental set to true when it has
249
* finished processing one FramebufferUpdate and is ready to process another.
250
* With a fast client, the rate at which FramebufferUpdateRequests are sent
251
* should be regulated to avoid hogging the network.
256
/*****************************************************************************
260
*****************************************************************************/
262
/* server -> client */
264
#define rfbFramebufferUpdate 0
265
#define rfbSetColourMapEntries 1
267
#define rfbServerCutText 3
270
/* client -> server */
272
#define rfbSetPixelFormat 0
273
#define rfbFixColourMapEntries 1 /* not currently supported */
274
#define rfbSetEncodings 2
275
#define rfbFramebufferUpdateRequest 3
276
#define rfbKeyEvent 4
277
#define rfbPointerEvent 5
278
#define rfbClientCutText 6
283
/*****************************************************************************
287
*****************************************************************************/
289
#define rfbEncodingRaw 0
290
#define rfbEncodingCopyRect 1
291
#define rfbEncodingRRE 2
292
#define rfbEncodingCoRRE 4
293
#define rfbEncodingHextile 5
294
#define rfbEncodingZlib 6
295
#define rfbEncodingTight 7
296
#define rfbEncodingZlibHex 8
299
* Special encoding numbers:
300
* 0xFFFFFF00 .. 0xFFFFFF0F -- encoding-specific compression levels;
301
* 0xFFFFFF10 .. 0xFFFFFF1F -- mouse cursor shape data;
302
* 0xFFFFFF20 .. 0xFFFFFF2F -- various protocol extensions;
303
* 0xFFFFFF30 .. 0xFFFFFFDF -- not allocated yet;
304
* 0xFFFFFFE0 .. 0xFFFFFFEF -- quality level for JPEG compressor;
305
* 0xFFFFFFF0 .. 0xFFFFFFFF -- cross-encoding compression levels.
308
#define rfbEncodingCompressLevel0 0xFFFFFF00
309
#define rfbEncodingCompressLevel1 0xFFFFFF01
310
#define rfbEncodingCompressLevel2 0xFFFFFF02
311
#define rfbEncodingCompressLevel3 0xFFFFFF03
312
#define rfbEncodingCompressLevel4 0xFFFFFF04
313
#define rfbEncodingCompressLevel5 0xFFFFFF05
314
#define rfbEncodingCompressLevel6 0xFFFFFF06
315
#define rfbEncodingCompressLevel7 0xFFFFFF07
316
#define rfbEncodingCompressLevel8 0xFFFFFF08
317
#define rfbEncodingCompressLevel9 0xFFFFFF09
319
#define rfbEncodingXCursor 0xFFFFFF10
320
#define rfbEncodingRichCursor 0xFFFFFF11
321
#define rfbEncodingPointerPos 0xFFFFFF18
323
#define rfbEncodingLastRect 0xFFFFFF20
325
#define rfbEncodingQualityLevel0 0xFFFFFFE0
326
#define rfbEncodingQualityLevel1 0xFFFFFFE1
327
#define rfbEncodingQualityLevel2 0xFFFFFFE2
328
#define rfbEncodingQualityLevel3 0xFFFFFFE3
329
#define rfbEncodingQualityLevel4 0xFFFFFFE4
330
#define rfbEncodingQualityLevel5 0xFFFFFFE5
331
#define rfbEncodingQualityLevel6 0xFFFFFFE6
332
#define rfbEncodingQualityLevel7 0xFFFFFFE7
333
#define rfbEncodingQualityLevel8 0xFFFFFFE8
334
#define rfbEncodingQualityLevel9 0xFFFFFFE9
337
/*****************************************************************************
339
* Server -> client message definitions
341
*****************************************************************************/
344
/*-----------------------------------------------------------------------------
345
* FramebufferUpdate - a block of rectangles to be copied to the framebuffer.
347
* This message consists of a header giving the number of rectangles of pixel
348
* data followed by the rectangles themselves. The header is padded so that
349
* together with the type byte it is an exact multiple of 4 bytes (to help
350
* with alignment of 32-bit pixels):
354
CARD8 type; /* always rfbFramebufferUpdate */
357
/* followed by nRects rectangles */
358
} rfbFramebufferUpdateMsg;
360
#define sz_rfbFramebufferUpdateMsg 4
363
* Each rectangle of pixel data consists of a header describing the position
364
* and size of the rectangle and a type word describing the encoding of the
365
* pixel data, followed finally by the pixel data. Note that if the client has
366
* not sent a SetEncodings message then it will only receive raw pixel data.
367
* Also note again that this structure is a multiple of 4 bytes.
372
CARD32 encoding; /* one of the encoding types rfbEncoding... */
373
} rfbFramebufferUpdateRectHeader;
375
#define sz_rfbFramebufferUpdateRectHeader (sz_rfbRectangle + 4)
378
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
379
* Raw Encoding. Pixels are sent in top-to-bottom scanline order,
380
* left-to-right within a scanline with no padding in between.
384
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
385
* CopyRect Encoding. The pixels are specified simply by the x and y position
386
* of the source rectangle.
394
#define sz_rfbCopyRect 4
397
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
398
* RRE - Rise-and-Run-length Encoding. We have an rfbRREHeader structure
399
* giving the number of subrectangles following. Finally the data follows in
400
* the form [<bgpixel><subrect><subrect>...] where each <subrect> is
401
* [<pixel><rfbRectangle>].
408
#define sz_rfbRREHeader 4
411
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
412
* CoRRE - Compact RRE Encoding. We have an rfbRREHeader structure giving
413
* the number of subrectangles following. Finally the data follows in the form
414
* [<bgpixel><subrect><subrect>...] where each <subrect> is
415
* [<pixel><rfbCoRRERectangle>]. This means that
416
* the whole rectangle must be at most 255x255 pixels.
426
#define sz_rfbCoRRERectangle 4
429
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
430
* Hextile Encoding. The rectangle is divided up into "tiles" of 16x16 pixels,
431
* starting at the top left going in left-to-right, top-to-bottom order. If
432
* the width of the rectangle is not an exact multiple of 16 then the width of
433
* the last tile in each row will be correspondingly smaller. Similarly if the
434
* height is not an exact multiple of 16 then the height of each tile in the
435
* final row will also be smaller. Each tile begins with a "subencoding" type
436
* byte, which is a mask made up of a number of bits. If the Raw bit is set
437
* then the other bits are irrelevant; w*h pixel values follow (where w and h
438
* are the width and height of the tile). Otherwise the tile is encoded in a
439
* similar way to RRE, except that the position and size of each subrectangle
440
* can be specified in just two bytes. The other bits in the mask are as
443
* BackgroundSpecified - if set, a pixel value follows which specifies
444
* the background colour for this tile. The first non-raw tile in a
445
* rectangle must have this bit set. If this bit isn't set then the
446
* background is the same as the last tile.
448
* ForegroundSpecified - if set, a pixel value follows which specifies
449
* the foreground colour to be used for all subrectangles in this tile.
450
* If this bit is set then the SubrectsColoured bit must be zero.
452
* AnySubrects - if set, a single byte follows giving the number of
453
* subrectangles following. If not set, there are no subrectangles (i.e.
454
* the whole tile is just solid background colour).
456
* SubrectsColoured - if set then each subrectangle is preceded by a pixel
457
* value giving the colour of that subrectangle. If not set, all
458
* subrectangles are the same colour, the foreground colour; if the
459
* ForegroundSpecified bit wasn't set then the foreground is the same as
462
* The position and size of each subrectangle is specified in two bytes. The
463
* Pack macros below can be used to generate the two bytes from x, y, w, h,
464
* and the Extract macros can be used to extract the x, y, w, h values from
468
#define rfbHextileRaw (1 << 0)
469
#define rfbHextileBackgroundSpecified (1 << 1)
470
#define rfbHextileForegroundSpecified (1 << 2)
471
#define rfbHextileAnySubrects (1 << 3)
472
#define rfbHextileSubrectsColoured (1 << 4)
474
#define rfbHextilePackXY(x,y) (((x) << 4) | (y))
475
#define rfbHextilePackWH(w,h) ((((w)-1) << 4) | ((h)-1))
476
#define rfbHextileExtractX(byte) ((byte) >> 4)
477
#define rfbHextileExtractY(byte) ((byte) & 0xf)
478
#define rfbHextileExtractW(byte) (((byte) >> 4) + 1)
479
#define rfbHextileExtractH(byte) (((byte) & 0xf) + 1)
482
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
483
* zlib - zlib compressed Encoding. We have an rfbZlibHeader structure
484
* giving the number of bytes following. Finally the data follows is
485
* zlib compressed version of the raw pixel data as negotiated.
492
#define sz_rfbZlibHeader 4
495
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
498
*-- The first byte of each Tight-encoded rectangle is a "compression control
499
* byte". Its format is as follows (bit 0 is the least significant one):
501
* bit 0: if 1, then compression stream 0 should be reset;
502
* bit 1: if 1, then compression stream 1 should be reset;
503
* bit 2: if 1, then compression stream 2 should be reset;
504
* bit 3: if 1, then compression stream 3 should be reset;
505
* bits 7-4: if 1000 (0x08), then the compression type is "fill",
506
* if 1001 (0x09), then the compression type is "jpeg",
507
* if 0xxx, then the compression type is "basic",
508
* values greater than 1001 are not valid.
510
* If the compression type is "basic", then bits 6..4 of the
511
* compression control byte (those xxx in 0xxx) specify the following:
513
* bits 5-4: decimal representation is the index of a particular zlib
514
* stream which should be used for decompressing the data;
515
* bit 6: if 1, then a "filter id" byte is following this byte.
517
*-- The data that follows after the compression control byte described
518
* above depends on the compression type ("fill", "jpeg" or "basic").
520
*-- If the compression type is "fill", then the only pixel value follows, in
521
* client pixel format (see NOTE 1). This value applies to all pixels of the
524
*-- If the compression type is "jpeg", the following data stream looks like
527
* 1..3 bytes: data size (N) in compact representation;
528
* N bytes: JPEG image.
530
* Data size is compactly represented in one, two or three bytes, according
531
* to the following scheme:
533
* 0xxxxxxx (for values 0..127)
534
* 1xxxxxxx 0yyyyyyy (for values 128..16383)
535
* 1xxxxxxx 1yyyyyyy zzzzzzzz (for values 16384..4194303)
537
* Here each character denotes one bit, xxxxxxx are the least significant 7
538
* bits of the value (bits 0-6), yyyyyyy are bits 7-13, and zzzzzzzz are the
539
* most significant 8 bits (bits 14-21). For example, decimal value 10000
540
* should be represented as two bytes: binary 10010000 01001110, or
543
*-- If the compression type is "basic" and bit 6 of the compression control
544
* byte was set to 1, then the next (second) byte specifies "filter id" which
545
* tells the decoder what filter type was used by the encoder to pre-process
546
* pixel data before the compression. The "filter id" byte can be one of the
549
* 0: no filter ("copy" filter);
550
* 1: "palette" filter;
551
* 2: "gradient" filter.
553
*-- If bit 6 of the compression control byte is set to 0 (no "filter id"
554
* byte), or if the filter id is 0, then raw pixel values in the client
555
* format (see NOTE 1) will be compressed. See below details on the
558
*-- The "gradient" filter pre-processes pixel data with a simple algorithm
559
* which converts each color component to a difference between a "predicted"
560
* intensity and the actual intensity. Such a technique does not affect
561
* uncompressed data size, but helps to compress photo-like images better.
562
* Pseudo-code for converting intensities to differences is the following:
564
* P[i,j] := V[i-1,j] + V[i,j-1] - V[i-1,j-1];
565
* if (P[i,j] < 0) then P[i,j] := 0;
566
* if (P[i,j] > MAX) then P[i,j] := MAX;
567
* D[i,j] := V[i,j] - P[i,j];
569
* Here V[i,j] is the intensity of a color component for a pixel at
570
* coordinates (i,j). MAX is the maximum value of intensity for a color
573
*-- The "palette" filter converts true-color pixel data to indexed colors
574
* and a palette which can consist of 2..256 colors. If the number of colors
575
* is 2, then each pixel is encoded in 1 bit, otherwise 8 bits is used to
576
* encode one pixel. 1-bit encoding is performed such way that the most
577
* significant bits correspond to the leftmost pixels, and each raw of pixels
578
* is aligned to the byte boundary. When "palette" filter is used, the
579
* palette is sent before the pixel data. The palette begins with an unsigned
580
* byte which value is the number of colors in the palette minus 1 (i.e. 1
581
* means 2 colors, 255 means 256 colors in the palette). Then follows the
582
* palette itself which consist of pixel values in client pixel format (see
585
*-- The pixel data is compressed using the zlib library. But if the data
586
* size after applying the filter but before the compression is less then 12,
587
* then the data is sent as is, uncompressed. Four separate zlib streams
588
* (0..3) can be used and the decoder should read the actual stream id from
589
* the compression control byte (see NOTE 2).
591
* If the compression is not used, then the pixel data is sent as is,
592
* otherwise the data stream looks like this:
594
* 1..3 bytes: data size (N) in compact representation;
595
* N bytes: zlib-compressed data.
597
* Data size is compactly represented in one, two or three bytes, just like
598
* in the "jpeg" compression method (see above).
600
*-- NOTE 1. If the color depth is 24, and all three color components are
601
* 8-bit wide, then one pixel in Tight encoding is always represented by
602
* three bytes, where the first byte is red component, the second byte is
603
* green component, and the third byte is blue component of the pixel color
604
* value. This applies to colors in palettes as well.
606
*-- NOTE 2. The decoder must reset compression streams' states before
607
* decoding the rectangle, if some of bits 0,1,2,3 in the compression control
608
* byte are set to 1. Note that the decoder must reset zlib streams even if
609
* the compression type is "fill" or "jpeg".
611
*-- NOTE 3. The "gradient" filter and "jpeg" compression may be used only
612
* when bits-per-pixel value is either 16 or 32, not 8.
614
*-- NOTE 4. The width of any Tight-encoded rectangle cannot exceed 2048
615
* pixels. If a rectangle is wider, it must be split into several rectangles
616
* and each one should be encoded separately.
620
#define rfbTightExplicitFilter 0x04
621
#define rfbTightFill 0x08
622
#define rfbTightJpeg 0x09
623
#define rfbTightMaxSubencoding 0x09
625
/* Filters to improve compression efficiency */
626
#define rfbTightFilterCopy 0x00
627
#define rfbTightFilterPalette 0x01
628
#define rfbTightFilterGradient 0x02
631
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
632
* XCursor encoding. This is a special encoding used to transmit X-style
633
* cursor shapes from server to clients. Note that for this encoding,
634
* coordinates in rfbFramebufferUpdateRectHeader structure hold hotspot
635
* position (r.x, r.y) and cursor size (r.w, r.h). If (w * h != 0), two RGB
636
* samples are sent after header in the rfbXCursorColors structure. They
637
* denote foreground and background colors of the cursor. If a client
638
* supports only black-and-white cursors, it should ignore these colors and
639
* assume that foreground is black and background is white. Next, two bitmaps
640
* (1 bits per pixel) follow: first one with actual data (value 0 denotes
641
* background color, value 1 denotes foreground color), second one with
642
* transparency data (bits with zero value mean that these pixels are
643
* transparent). Both bitmaps represent cursor data in a byte stream, from
644
* left to right, from top to bottom, and each row is byte-aligned. Most
645
* significant bits correspond to leftmost pixels. The number of bytes in
646
* each row can be calculated as ((w + 7) / 8). If (w * h == 0), cursor
647
* should be hidden (or default local cursor should be set by the client).
659
#define sz_rfbXCursorColors 6
662
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
663
* RichCursor encoding. This is a special encoding used to transmit cursor
664
* shapes from server to clients. It is similar to the XCursor encoding but
665
* uses client pixel format instead of two RGB colors to represent cursor
666
* image. For this encoding, coordinates in rfbFramebufferUpdateRectHeader
667
* structure hold hotspot position (r.x, r.y) and cursor size (r.w, r.h).
668
* After header, two pixmaps follow: first one with cursor image in current
669
* client pixel format (like in raw encoding), second with transparency data
670
* (1 bit per pixel, exactly the same format as used for transparency bitmap
671
* in the XCursor encoding). If (w * h == 0), cursor should be hidden (or
672
* default local cursor should be set by the client).
676
/*-----------------------------------------------------------------------------
677
* SetColourMapEntries - these messages are only sent if the pixel
678
* format uses a "colour map" (i.e. trueColour false) and the client has not
679
* fixed the entire colour map using FixColourMapEntries. In addition they
680
* will only start being sent after the client has sent its first
681
* FramebufferUpdateRequest. So if the client always tells the server to use
682
* trueColour then it never needs to process this type of message.
686
CARD8 type; /* always rfbSetColourMapEntries */
691
/* Followed by nColours * 3 * CARD16
692
r1, g1, b1, r2, g2, b2, r3, g3, b3, ..., rn, bn, gn */
694
} rfbSetColourMapEntriesMsg;
696
#define sz_rfbSetColourMapEntriesMsg 6
700
/*-----------------------------------------------------------------------------
701
* Bell - ring a bell on the client if it has one.
705
CARD8 type; /* always rfbBell */
708
#define sz_rfbBellMsg 1
712
/*-----------------------------------------------------------------------------
713
* ServerCutText - the server has new text in its cut buffer.
717
CARD8 type; /* always rfbServerCutText */
721
/* followed by char text[length] */
722
} rfbServerCutTextMsg;
724
#define sz_rfbServerCutTextMsg 8
727
/*-----------------------------------------------------------------------------
728
* Union of all server->client messages.
733
rfbFramebufferUpdateMsg fu;
734
rfbSetColourMapEntriesMsg scme;
736
rfbServerCutTextMsg sct;
737
} rfbServerToClientMsg;
741
/*****************************************************************************
743
* Message definitions (client -> server)
745
*****************************************************************************/
748
/*-----------------------------------------------------------------------------
749
* SetPixelFormat - tell the RFB server the format in which the client wants
754
CARD8 type; /* always rfbSetPixelFormat */
757
rfbPixelFormat format;
758
} rfbSetPixelFormatMsg;
760
#define sz_rfbSetPixelFormatMsg (sz_rfbPixelFormat + 4)
763
/*-----------------------------------------------------------------------------
764
* FixColourMapEntries - when the pixel format uses a "colour map", fix
765
* read-only colour map entries.
767
* ***************** NOT CURRENTLY SUPPORTED *****************
771
CARD8 type; /* always rfbFixColourMapEntries */
776
/* Followed by nColours * 3 * CARD16
777
r1, g1, b1, r2, g2, b2, r3, g3, b3, ..., rn, bn, gn */
779
} rfbFixColourMapEntriesMsg;
781
#define sz_rfbFixColourMapEntriesMsg 6
784
/*-----------------------------------------------------------------------------
785
* SetEncodings - tell the RFB server which encoding types we accept. Put them
786
* in order of preference, if we have any. We may always receive raw
787
* encoding, even if we don't specify it here.
791
CARD8 type; /* always rfbSetEncodings */
794
/* followed by nEncodings * CARD32 encoding types */
795
} rfbSetEncodingsMsg;
797
#define sz_rfbSetEncodingsMsg 4
800
/*-----------------------------------------------------------------------------
801
* FramebufferUpdateRequest - request for a framebuffer update. If incremental
802
* is true then the client just wants the changes since the last update. If
803
* false then it wants the whole of the specified rectangle.
807
CARD8 type; /* always rfbFramebufferUpdateRequest */
813
} rfbFramebufferUpdateRequestMsg;
815
#define sz_rfbFramebufferUpdateRequestMsg 10
818
/*-----------------------------------------------------------------------------
819
* KeyEvent - key press or release
821
* Keys are specified using the "keysym" values defined by the X Window System.
822
* For most ordinary keys, the keysym is the same as the corresponding ASCII
823
* value. Other common keys are:
827
* Return or Enter 0xff0d
850
CARD8 type; /* always rfbKeyEvent */
851
CARD8 down; /* true if down (press), false if up */
853
CARD32 key; /* key is specified as an X keysym */
856
#define sz_rfbKeyEventMsg 8
859
/*-----------------------------------------------------------------------------
860
* PointerEvent - mouse/pen move and/or button press.
864
CARD8 type; /* always rfbPointerEvent */
865
CARD8 buttonMask; /* bits 0-7 are buttons 1-8, 0=up, 1=down */
868
} rfbPointerEventMsg;
870
#define rfbButton1Mask 1
871
#define rfbButton2Mask 2
872
#define rfbButton3Mask 4
874
#define sz_rfbPointerEventMsg 6
878
/*-----------------------------------------------------------------------------
879
* ClientCutText - the client has new text in its cut buffer.
883
CARD8 type; /* always rfbClientCutText */
887
/* followed by char text[length] */
888
} rfbClientCutTextMsg;
890
#define sz_rfbClientCutTextMsg 8
894
/*-----------------------------------------------------------------------------
895
* Union of all client->server messages.
900
rfbSetPixelFormatMsg spf;
901
rfbFixColourMapEntriesMsg fcme;
902
rfbSetEncodingsMsg se;
903
rfbFramebufferUpdateRequestMsg fur;
905
rfbPointerEventMsg pe;
906
rfbClientCutTextMsg cct;
907
} rfbClientToServerMsg;
added
removed
client/demoviewer/rfbproto.h
