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 | } ; |
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 | } ; |
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 | } ; |
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 | } ; |
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 | |