Wireshark  2.9.0-477-g68ec514b
The Wireshark network protocol analyzer
packet-spice.h
1 /*
2  Copyright (C) 2013 Red Hat, Inc.
3 
4  This library is free software; you can redistribute it and/or
5  modify it under the terms of the GNU Lesser General Public
6  License as published by the Free Software Foundation; either
7  version 2.1 of the License, or (at your option) any later version.
8 
9  This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  Lesser General Public License for more details.
13 
14  You should have received a copy of the GNU Lesser General Public
15  License along with this library; if not, see <http://www.gnu.org/licenses/>.
16 */
17 
18 /* NOTE:
19  * packet-spice.h is auto-generated from a Spice protocol definition by a tool
20  * included in the spice-common repository
21  * (http://cgit.freedesktop.org/spice/spice-common/)
22  * To re-generate this file, run the following command from the root of the
23  * spice-common tree:
24  * python ./spice_codegen.py --generate-wireshark-dissector \
25  * spice.proto packet-spice.h
26  */
27 #ifndef _H_SPICE_ENUMS
28 #define _H_SPICE_ENUMS
29 
30 /* Generated from spice.proto, don't edit */
31 
32 typedef enum SpiceLinkErr {
33  SPICE_LINK_ERR_OK,
34  SPICE_LINK_ERR_ERROR,
35  SPICE_LINK_ERR_INVALID_MAGIC,
36  SPICE_LINK_ERR_INVALID_DATA,
37  SPICE_LINK_ERR_VERSION_MISMATCH,
38  SPICE_LINK_ERR_NEED_SECURED,
39  SPICE_LINK_ERR_NEED_UNSECURED,
40  SPICE_LINK_ERR_PERMISSION_DENIED,
41  SPICE_LINK_ERR_BAD_CONNECTION_ID,
42  SPICE_LINK_ERR_CHANNEL_NOT_AVAILABLE,
43 
44  SPICE_LINK_ERR_ENUM_END
45 } SpiceLinkErr;
46 
47 static const value_string spice_link_err_vs[] = {
48  { SPICE_LINK_ERR_OK, "OK" },
49  { SPICE_LINK_ERR_ERROR, "ERROR" },
50  { SPICE_LINK_ERR_INVALID_MAGIC, "INVALID_MAGIC" },
51  { SPICE_LINK_ERR_INVALID_DATA, "INVALID_DATA" },
52  { SPICE_LINK_ERR_VERSION_MISMATCH, "VERSION_MISMATCH" },
53  { SPICE_LINK_ERR_NEED_SECURED, "NEED_SECURED" },
54  { SPICE_LINK_ERR_NEED_UNSECURED, "NEED_UNSECURED" },
55  { SPICE_LINK_ERR_PERMISSION_DENIED, "PERMISSION_DENIED" },
56  { SPICE_LINK_ERR_BAD_CONNECTION_ID, "BAD_CONNECTION_ID" },
57  { SPICE_LINK_ERR_CHANNEL_NOT_AVAILABLE, "CHANNEL_NOT_AVAILABLE" },
58  { 0, NULL } };
59 
60 #if 0
61 typedef enum SpiceWarnCode {
62  SPICE_WARN_GENERAL,
63 
64  SPICE_WARN_CODE_ENUM_END
65 } SpiceWarnCode;
66 
67 static const value_string spice_warn_code_vs[] = {
68  { SPICE_WARN_GENERAL, "WARN_GENERAL" },
69  { 0, NULL } };
70 
71 typedef enum SpiceInfoCode {
72  SPICE_INFO_GENERAL,
73 
74  SPICE_INFO_CODE_ENUM_END
75 } SpiceInfoCode;
76 
77 static const value_string spice_info_code_vs[] = {
78  { SPICE_INFO_GENERAL, "INFO_GENERAL" },
79  { 0, NULL } };
80 
81 typedef enum SpiceMigrateFlags {
82  SPICE_MIGRATE_NEED_FLUSH = (1 << 0),
83  SPICE_MIGRATE_NEED_DATA_TRANSFER = (1 << 1),
84 
85  SPICE_MIGRATE_FLAGS_MASK = 0x3
86 } SpiceMigrateFlags;
87 
88 static const value_string spice_migrate_flags_vs[] = {
89  { SPICE_MIGRATE_NEED_FLUSH, "NEED_FLUSH" },
90  { SPICE_MIGRATE_NEED_DATA_TRANSFER, "NEED_DATA_TRANSFER" },
91  { 0, NULL } };
92 
93 typedef enum SpiceCompositeFlags {
94  SPICE_COMPOSITE_OP0 = (1 << 0),
95  SPICE_COMPOSITE_OP1 = (1 << 1),
96  SPICE_COMPOSITE_OP2 = (1 << 2),
97  SPICE_COMPOSITE_OP3 = (1 << 3),
98  SPICE_COMPOSITE_OP4 = (1 << 4),
99  SPICE_COMPOSITE_OP5 = (1 << 5),
100  SPICE_COMPOSITE_OP6 = (1 << 6),
101  SPICE_COMPOSITE_OP7 = (1 << 7),
102  SPICE_COMPOSITE_SRC_FILTER0 = (1 << 8),
103  SPICE_COMPOSITE_SRC_FILTER1 = (1 << 9),
104  SPICE_COMPOSITE_SRC_FILTER2 = (1 << 10),
105  SPICE_COMPOSITE_MASK_FILTER0 = (1 << 11),
106  SPICE_COMPOSITE_MASK_FITLER1 = (1 << 12),
107  SPICE_COMPOSITE_MASK_FILTER2 = (1 << 13),
108  SPICE_COMPOSITE_SRC_REPEAT0 = (1 << 14),
109  SPICE_COMPOSITE_SRC_REPEAT1 = (1 << 15),
110  SPICE_COMPOSITE_MASK_REPEAT0 = (1 << 16),
111  SPICE_COMPOSITE_MASK_REPEAT1 = (1 << 17),
112  SPICE_COMPOSITE_COMPONENT_ALPHA = (1 << 18),
113  SPICE_COMPOSITE_HAS_MASK = (1 << 19),
114  SPICE_COMPOSITE_HAS_SRC_TRANSFORM = (1 << 20),
115  SPICE_COMPOSITE_HAS_MASK_TRANSFORM = (1 << 21),
116  SPICE_COMPOSITE_SOURCE_OPAQUE = (1 << 22),
117  SPICE_COMPOSITE_MASK_OPAQUE = (1 << 23),
118  SPICE_COMPOSITE_DEST_OPAQUE = (1 << 24),
119 
120  SPICE_COMPOSITE_FLAGS_MASK = 0x1ffffff
121 } SpiceCompositeFlags;
122 
123 static const value_string spice_composite_flags_vs[] = {
124  { SPICE_COMPOSITE_OP0, "OP0" },
125  { SPICE_COMPOSITE_OP1, "OP1" },
126  { SPICE_COMPOSITE_OP2, "OP2" },
127  { SPICE_COMPOSITE_OP3, "OP3" },
128  { SPICE_COMPOSITE_OP4, "OP4" },
129  { SPICE_COMPOSITE_OP5, "OP5" },
130  { SPICE_COMPOSITE_OP6, "OP6" },
131  { SPICE_COMPOSITE_OP7, "OP7" },
132  { SPICE_COMPOSITE_SRC_FILTER0, "SRC_FILTER0" },
133  { SPICE_COMPOSITE_SRC_FILTER1, "SRC_FILTER1" },
134  { SPICE_COMPOSITE_SRC_FILTER2, "SRC_FILTER2" },
135  { SPICE_COMPOSITE_MASK_FILTER0, "MASK_FILTER0" },
136  { SPICE_COMPOSITE_MASK_FITLER1, "MASK_FITLER1" },
137  { SPICE_COMPOSITE_MASK_FILTER2, "MASK_FILTER2" },
138  { SPICE_COMPOSITE_SRC_REPEAT0, "SRC_REPEAT0" },
139  { SPICE_COMPOSITE_SRC_REPEAT1, "SRC_REPEAT1" },
140  { SPICE_COMPOSITE_MASK_REPEAT0, "MASK_REPEAT0" },
141  { SPICE_COMPOSITE_MASK_REPEAT1, "MASK_REPEAT1" },
142  { SPICE_COMPOSITE_COMPONENT_ALPHA, "COMPONENT_ALPHA" },
143  { SPICE_COMPOSITE_HAS_MASK, "HAS_MASK" },
144  { SPICE_COMPOSITE_HAS_SRC_TRANSFORM, "HAS_SRC_TRANSFORM" },
145  { SPICE_COMPOSITE_HAS_MASK_TRANSFORM, "HAS_MASK_TRANSFORM" },
146  { SPICE_COMPOSITE_SOURCE_OPAQUE, "SOURCE_OPAQUE" },
147  { SPICE_COMPOSITE_MASK_OPAQUE, "MASK_OPAQUE" },
148  { SPICE_COMPOSITE_DEST_OPAQUE, "DEST_OPAQUE" },
149  { 0, NULL } };
150 #endif
151 
152 typedef enum SpiceNotifySeverity {
153  SPICE_NOTIFY_SEVERITY_INFO,
154  SPICE_NOTIFY_SEVERITY_WARN,
155  SPICE_NOTIFY_SEVERITY_ERROR,
156 
157  SPICE_NOTIFY_SEVERITY_ENUM_END
158 } SpiceNotifySeverity;
159 
160 static const value_string spice_notify_severity_vs[] = {
161  { SPICE_NOTIFY_SEVERITY_INFO, "INFO" },
162  { SPICE_NOTIFY_SEVERITY_WARN, "WARN" },
163  { SPICE_NOTIFY_SEVERITY_ERROR, "ERROR" },
164  { 0, NULL } };
165 
166 typedef enum SpiceNotifyVisibility {
167  SPICE_NOTIFY_VISIBILITY_LOW,
168  SPICE_NOTIFY_VISIBILITY_MEDIUM,
169  SPICE_NOTIFY_VISIBILITY_HIGH,
170 
171  SPICE_NOTIFY_VISIBILITY_ENUM_END
172 } SpiceNotifyVisibility;
173 
174 static const value_string spice_notify_visibility_vs[] = {
175  { SPICE_NOTIFY_VISIBILITY_LOW, "LOW" },
176  { SPICE_NOTIFY_VISIBILITY_MEDIUM, "MEDIUM" },
177  { SPICE_NOTIFY_VISIBILITY_HIGH, "HIGH" },
178  { 0, NULL } };
179 
180 typedef enum SpiceMouseMode {
181  SPICE_MOUSE_MODE_SERVER = (1 << 0),
182  SPICE_MOUSE_MODE_CLIENT = (1 << 1),
183 
184  SPICE_MOUSE_MODE_MASK = 0x3
185 } SpiceMouseMode;
186 
187 static const value_string spice_mouse_mode_vs[] = {
188  { SPICE_MOUSE_MODE_SERVER, "SERVER" },
189  { SPICE_MOUSE_MODE_CLIENT, "CLIENT" },
190  { 0, NULL } };
191 
192 #if 0
193 typedef enum SpicePubkeyType {
194  SPICE_PUBKEY_TYPE_INVALID,
195  SPICE_PUBKEY_TYPE_RSA,
196  SPICE_PUBKEY_TYPE_RSA2,
197  SPICE_PUBKEY_TYPE_DSA,
198  SPICE_PUBKEY_TYPE_DSA1,
199  SPICE_PUBKEY_TYPE_DSA2,
200  SPICE_PUBKEY_TYPE_DSA3,
201  SPICE_PUBKEY_TYPE_DSA4,
202  SPICE_PUBKEY_TYPE_DH,
203  SPICE_PUBKEY_TYPE_EC,
204 
205  SPICE_PUBKEY_TYPE_ENUM_END
206 } SpicePubkeyType;
207 
208 static const value_string spice_pubkey_type_vs[] = {
209  { SPICE_PUBKEY_TYPE_INVALID, "INVALID" },
210  { SPICE_PUBKEY_TYPE_RSA, "RSA" },
211  { SPICE_PUBKEY_TYPE_RSA2, "RSA2" },
212  { SPICE_PUBKEY_TYPE_DSA, "DSA" },
213  { SPICE_PUBKEY_TYPE_DSA1, "DSA1" },
214  { SPICE_PUBKEY_TYPE_DSA2, "DSA2" },
215  { SPICE_PUBKEY_TYPE_DSA3, "DSA3" },
216  { SPICE_PUBKEY_TYPE_DSA4, "DSA4" },
217  { SPICE_PUBKEY_TYPE_DH, "DH" },
218  { SPICE_PUBKEY_TYPE_EC, "EC" },
219  { 0, NULL } };
220 #endif
221 
222 typedef enum SpiceClipType {
223  SPICE_CLIP_TYPE_NONE,
224  SPICE_CLIP_TYPE_RECTS,
225 
226  SPICE_CLIP_TYPE_ENUM_END
227 } SpiceClipType;
228 
229 static const value_string spice_clip_type_vs[] = {
230  { SPICE_CLIP_TYPE_NONE, "NONE" },
231  { SPICE_CLIP_TYPE_RECTS, "RECTS" },
232  { 0, NULL } };
233 
234 #if 0
235 typedef enum SpicePathFlags {
236  SPICE_PATH_BEGIN = (1 << 0),
237  SPICE_PATH_END = (1 << 1),
238  SPICE_PATH_CLOSE = (1 << 3),
239  SPICE_PATH_BEZIER = (1 << 4),
240 
241  SPICE_PATH_FLAGS_MASK = 0x1b
242 } SpicePathFlags;
243 
244 static const value_string spice_path_flags_vs[] = {
245  { SPICE_PATH_BEGIN, "BEGIN" },
246  { SPICE_PATH_END, "END" },
247  { SPICE_PATH_CLOSE, "CLOSE" },
248  { SPICE_PATH_BEZIER, "BEZIER" },
249  { 0, NULL } };
250 #endif
251 
252 typedef enum SpiceVideoCodecType {
253  SPICE_VIDEO_CODEC_TYPE_MJPEG = 1,
254 
255  SPICE_VIDEO_CODEC_TYPE_ENUM_END
256 } SpiceVideoCodecType;
257 
258 static const value_string spice_video_codec_type_vs[] = {
259  { SPICE_VIDEO_CODEC_TYPE_MJPEG, "MJPEG" },
260  { 0, NULL } };
261 
262 typedef enum SpiceStreamFlags {
263  SPICE_STREAM_FLAGS_TOP_DOWN = (1 << 0),
264 
265  SPICE_STREAM_FLAGS_MASK = 0x1
266 } SpiceStreamFlags;
267 
268 static const value_string spice_stream_flags_vs[] = {
269  { SPICE_STREAM_FLAGS_TOP_DOWN, "TOP_DOWN" },
270  { 0, NULL } };
271 
272 typedef enum SpiceBrushType {
273  SPICE_BRUSH_TYPE_NONE,
274  SPICE_BRUSH_TYPE_SOLID,
275  SPICE_BRUSH_TYPE_PATTERN,
276 
277  SPICE_BRUSH_TYPE_ENUM_END
278 } SpiceBrushType;
279 
280 static const value_string spice_brush_type_vs[] = {
281  { SPICE_BRUSH_TYPE_NONE, "NONE" },
282  { SPICE_BRUSH_TYPE_SOLID, "SOLID" },
283  { SPICE_BRUSH_TYPE_PATTERN, "PATTERN" },
284  { 0, NULL } };
285 
286 typedef enum SpiceMaskFlags {
287  SPICE_MASK_FLAGS_INVERS = (1 << 0),
288 
289  SPICE_MASK_FLAGS_MASK = 0x1
290 } SpiceMaskFlags;
291 
292 static const value_string spice_mask_flags_vs[] = {
293  { SPICE_MASK_FLAGS_INVERS, "INVERS" },
294  { 0, NULL } };
295 
296 typedef enum SpiceImageType {
297  SPICE_IMAGE_TYPE_BITMAP,
298  SPICE_IMAGE_TYPE_QUIC,
299  SPICE_IMAGE_TYPE_RESERVED,
300  SPICE_IMAGE_TYPE_LZ_PLT = 100,
301  SPICE_IMAGE_TYPE_LZ_RGB,
302  SPICE_IMAGE_TYPE_GLZ_RGB,
303  SPICE_IMAGE_TYPE_FROM_CACHE,
304  SPICE_IMAGE_TYPE_SURFACE,
305  SPICE_IMAGE_TYPE_JPEG,
306  SPICE_IMAGE_TYPE_FROM_CACHE_LOSSLESS,
307  SPICE_IMAGE_TYPE_ZLIB_GLZ_RGB,
308  SPICE_IMAGE_TYPE_JPEG_ALPHA,
309 
310  SPICE_IMAGE_TYPE_ENUM_END
311 } SpiceImageType;
312 
313 static const value_string spice_image_type_vs[] = {
314  { SPICE_IMAGE_TYPE_BITMAP, "BITMAP" },
315  { SPICE_IMAGE_TYPE_QUIC, "QUIC" },
316  { SPICE_IMAGE_TYPE_RESERVED, "RESERVED" },
317  { SPICE_IMAGE_TYPE_LZ_PLT, "LZ_PLT" },
318  { SPICE_IMAGE_TYPE_LZ_RGB, "LZ_RGB" },
319  { SPICE_IMAGE_TYPE_GLZ_RGB, "GLZ_RGB" },
320  { SPICE_IMAGE_TYPE_FROM_CACHE, "FROM_CACHE" },
321  { SPICE_IMAGE_TYPE_SURFACE, "SURFACE" },
322  { SPICE_IMAGE_TYPE_JPEG, "JPEG" },
323  { SPICE_IMAGE_TYPE_FROM_CACHE_LOSSLESS, "FROM_CACHE_LOSSLESS" },
324  { SPICE_IMAGE_TYPE_ZLIB_GLZ_RGB, "ZLIB_GLZ_RGB" },
325  { SPICE_IMAGE_TYPE_JPEG_ALPHA, "JPEG_ALPHA" },
326  { 0, NULL } };
327 
328 typedef enum SpiceImageFlags {
329  SPICE_IMAGE_FLAGS_CACHE_ME = (1 << 0),
330  SPICE_IMAGE_FLAGS_HIGH_BITS_SET = (1 << 1),
331  SPICE_IMAGE_FLAGS_CACHE_REPLACE_ME = (1 << 2),
332 
333  SPICE_IMAGE_FLAGS_MASK = 0x7
334 } SpiceImageFlags;
335 
336 static const value_string spice_image_flags_vs[] = {
337  { SPICE_IMAGE_FLAGS_CACHE_ME, "CACHE_ME" },
338  { SPICE_IMAGE_FLAGS_HIGH_BITS_SET, "HIGH_BITS_SET" },
339  { SPICE_IMAGE_FLAGS_CACHE_REPLACE_ME, "CACHE_REPLACE_ME" },
340  { 0, NULL } };
341 
342 typedef enum SpiceBitmapFmt {
343  SPICE_BITMAP_FMT_INVALID,
344  SPICE_BITMAP_FMT_1BIT_LE,
345  SPICE_BITMAP_FMT_1BIT_BE,
346  SPICE_BITMAP_FMT_4BIT_LE,
347  SPICE_BITMAP_FMT_4BIT_BE,
348  SPICE_BITMAP_FMT_8BIT,
349  SPICE_BITMAP_FMT_16BIT,
350  SPICE_BITMAP_FMT_24BIT,
351  SPICE_BITMAP_FMT_32BIT,
352  SPICE_BITMAP_FMT_RGBA,
353  SPICE_BITMAP_FMT_8BIT_A,
354 
355  SPICE_BITMAP_FMT_ENUM_END
356 } SpiceBitmapFmt;
357 
358 static const value_string spice_bitmap_fmt_vs[] = {
359  { SPICE_BITMAP_FMT_INVALID, "INVALID" },
360  { SPICE_BITMAP_FMT_1BIT_LE, "1BIT_LE" },
361  { SPICE_BITMAP_FMT_1BIT_BE, "1BIT_BE" },
362  { SPICE_BITMAP_FMT_4BIT_LE, "4BIT_LE" },
363  { SPICE_BITMAP_FMT_4BIT_BE, "4BIT_BE" },
364  { SPICE_BITMAP_FMT_8BIT, "8BIT" },
365  { SPICE_BITMAP_FMT_16BIT, "16BIT" },
366  { SPICE_BITMAP_FMT_24BIT, "24BIT" },
367  { SPICE_BITMAP_FMT_32BIT, "32BIT" },
368  { SPICE_BITMAP_FMT_RGBA, "RGBA" },
369  { SPICE_BITMAP_FMT_8BIT_A, "8BIT_A" },
370  { 0, NULL } };
371 
372 typedef enum SpiceBitmapFlags {
373  SPICE_BITMAP_FLAGS_PAL_CACHE_ME = (1 << 0),
374  SPICE_BITMAP_FLAGS_PAL_FROM_CACHE = (1 << 1),
375  SPICE_BITMAP_FLAGS_TOP_DOWN = (1 << 2),
376 
377  SPICE_BITMAP_FLAGS_MASK = 0x7
378 } SpiceBitmapFlags;
379 
380 static const value_string spice_bitmap_flags_vs[] = {
381  { SPICE_BITMAP_FLAGS_PAL_CACHE_ME, "PAL_CACHE_ME" },
382  { SPICE_BITMAP_FLAGS_PAL_FROM_CACHE, "PAL_FROM_CACHE" },
383  { SPICE_BITMAP_FLAGS_TOP_DOWN, "TOP_DOWN" },
384  { 0, NULL } };
385 
386 #if 0
387 typedef enum SpiceJpegAlphaFlags {
388  SPICE_JPEG_ALPHA_FLAGS_TOP_DOWN = (1 << 0),
389 
390  SPICE_JPEG_ALPHA_FLAGS_MASK = 0x1
391 } SpiceJpegAlphaFlags;
392 
393 static const value_string spice_jpeg_alpha_flags_vs[] = {
394  { SPICE_JPEG_ALPHA_FLAGS_TOP_DOWN, "TOP_DOWN" },
395  { 0, NULL } };
396 #endif
397 
398 typedef enum SpiceImageScaleMode {
399  SPICE_IMAGE_SCALE_MODE_INTERPOLATE,
400  SPICE_IMAGE_SCALE_MODE_NEAREST,
401 
402  SPICE_IMAGE_SCALE_MODE_ENUM_END
403 } SpiceImageScaleMode;
404 
405 static const value_string spice_image_scale_mode_vs[] = {
406  { SPICE_IMAGE_SCALE_MODE_INTERPOLATE, "INTERPOLATE" },
407  { SPICE_IMAGE_SCALE_MODE_NEAREST, "NEAREST" },
408  { 0, NULL } };
409 
410 typedef enum SpiceRopd {
411  SPICE_ROPD_INVERS_SRC = (1 << 0),
412  SPICE_ROPD_INVERS_BRUSH = (1 << 1),
413  SPICE_ROPD_INVERS_DEST = (1 << 2),
414  SPICE_ROPD_OP_PUT = (1 << 3),
415  SPICE_ROPD_OP_OR = (1 << 4),
416  SPICE_ROPD_OP_AND = (1 << 5),
417  SPICE_ROPD_OP_XOR = (1 << 6),
418  SPICE_ROPD_OP_BLACKNESS = (1 << 7),
419  SPICE_ROPD_OP_WHITENESS = (1 << 8),
420  SPICE_ROPD_OP_INVERS = (1 << 9),
421  SPICE_ROPD_INVERS_RES = (1 << 10),
422 
423  SPICE_ROPD_MASK = 0x7ff
424 } SpiceRopd;
425 
426 static const value_string spice_ropd_vs[] = {
427  { SPICE_ROPD_INVERS_SRC, "INVERS_SRC" },
428  { SPICE_ROPD_INVERS_BRUSH, "INVERS_BRUSH" },
429  { SPICE_ROPD_INVERS_DEST, "INVERS_DEST" },
430  { SPICE_ROPD_OP_PUT, "OP_PUT" },
431  { SPICE_ROPD_OP_OR, "OP_OR" },
432  { SPICE_ROPD_OP_AND, "OP_AND" },
433  { SPICE_ROPD_OP_XOR, "OP_XOR" },
434  { SPICE_ROPD_OP_BLACKNESS, "OP_BLACKNESS" },
435  { SPICE_ROPD_OP_WHITENESS, "OP_WHITENESS" },
436  { SPICE_ROPD_OP_INVERS, "OP_INVERS" },
437  { SPICE_ROPD_INVERS_RES, "INVERS_RES" },
438  { 0, NULL } };
439 
440 #if 0
441 typedef enum SpiceLineFlags {
442  SPICE_LINE_FLAGS_START_WITH_GAP = (1 << 2),
443  SPICE_LINE_FLAGS_STYLED = (1 << 3),
444 
445  SPICE_LINE_FLAGS_MASK = 0xc
446 } SpiceLineFlags;
447 
448 static const value_string spice_line_flags_vs[] = {
449  { SPICE_LINE_FLAGS_START_WITH_GAP, "START_WITH_GAP" },
450  { SPICE_LINE_FLAGS_STYLED, "STYLED" },
451  { 0, NULL } };
452 
453 typedef enum SpiceStringFlags {
454  SPICE_STRING_FLAGS_RASTER_A1 = (1 << 0),
455  SPICE_STRING_FLAGS_RASTER_A4 = (1 << 1),
456  SPICE_STRING_FLAGS_RASTER_A8 = (1 << 2),
457  SPICE_STRING_FLAGS_RASTER_TOP_DOWN = (1 << 3),
458 
459  SPICE_STRING_FLAGS_MASK = 0xf
460 } SpiceStringFlags;
461 
462 static const value_string spice_string_flags_vs[] = {
463  { SPICE_STRING_FLAGS_RASTER_A1, "RASTER_A1" },
464  { SPICE_STRING_FLAGS_RASTER_A4, "RASTER_A4" },
465  { SPICE_STRING_FLAGS_RASTER_A8, "RASTER_A8" },
466  { SPICE_STRING_FLAGS_RASTER_TOP_DOWN, "RASTER_TOP_DOWN" },
467  { 0, NULL } };
468 #endif
469 
470 typedef enum SpiceSurfaceFlags {
471  SPICE_SURFACE_FLAGS_PRIMARY = (1 << 0),
472 
473  SPICE_SURFACE_FLAGS_MASK = 0x1
474 } SpiceSurfaceFlags;
475 
476 static const value_string spice_surface_flags_vs[] = {
477  { SPICE_SURFACE_FLAGS_PRIMARY, "PRIMARY" },
478  { 0, NULL } };
479 
480 #if 0
481 typedef enum SpiceSurfaceFmt {
482  SPICE_SURFACE_FMT_INVALID,
483  SPICE_SURFACE_FMT_1_A,
484  SPICE_SURFACE_FMT_8_A = 8,
485  SPICE_SURFACE_FMT_16_555 = 16,
486  SPICE_SURFACE_FMT_32_XRGB = 32,
487  SPICE_SURFACE_FMT_16_565 = 80,
488  SPICE_SURFACE_FMT_32_ARGB = 96,
489 
490  SPICE_SURFACE_FMT_ENUM_END
491 } SpiceSurfaceFmt;
492 
493 static const value_string spice_surface_fmt_vs[] = {
494  { SPICE_SURFACE_FMT_INVALID, "INVALID" },
495  { SPICE_SURFACE_FMT_1_A, "1_A" },
496  { SPICE_SURFACE_FMT_8_A, "8_A" },
497  { SPICE_SURFACE_FMT_16_555, "16_555" },
498  { SPICE_SURFACE_FMT_32_XRGB, "32_xRGB" },
499  { SPICE_SURFACE_FMT_16_565, "16_565" },
500  { SPICE_SURFACE_FMT_32_ARGB, "32_ARGB" },
501  { 0, NULL } };
502 
503 typedef enum SpiceAlphaFlags {
504  SPICE_ALPHA_FLAGS_DEST_HAS_ALPHA = (1 << 0),
505  SPICE_ALPHA_FLAGS_SRC_SURFACE_HAS_ALPHA = (1 << 1),
506 
507  SPICE_ALPHA_FLAGS_MASK = 0x3
508 } SpiceAlphaFlags;
509 
510 static const value_string spice_alpha_flags_vs[] = {
511  { SPICE_ALPHA_FLAGS_DEST_HAS_ALPHA, "DEST_HAS_ALPHA" },
512  { SPICE_ALPHA_FLAGS_SRC_SURFACE_HAS_ALPHA, "SRC_SURFACE_HAS_ALPHA" },
513  { 0, NULL } };
514 
515 typedef enum SpiceResourceType {
516  SPICE_RES_TYPE_INVALID,
517  SPICE_RES_TYPE_PIXMAP,
518 
519  SPICE_RESOURCE_TYPE_ENUM_END
520 } SpiceResourceType;
521 
522 static const value_string spice_resource_type_vs[] = {
523  { SPICE_RES_TYPE_INVALID, "INVALID" },
524  { SPICE_RES_TYPE_PIXMAP, "PIXMAP" },
525  { 0, NULL } };
526 #endif
527 
528 typedef enum SpiceKeyboardModifierFlags {
529  SPICE_KEYBOARD_MODIFIER_FLAGS_SCROLL_LOCK = (1 << 0),
530  SPICE_KEYBOARD_MODIFIER_FLAGS_NUM_LOCK = (1 << 1),
531  SPICE_KEYBOARD_MODIFIER_FLAGS_CAPS_LOCK = (1 << 2),
532 
533  SPICE_KEYBOARD_MODIFIER_FLAGS_MASK = 0x7
534 } SpiceKeyboardModifierFlags;
535 
536 #if 0
537 static const value_string spice_keyboard_modifier_flags_vs[] = {
538  { SPICE_KEYBOARD_MODIFIER_FLAGS_SCROLL_LOCK, "SCROLL_LOCK" },
539  { SPICE_KEYBOARD_MODIFIER_FLAGS_NUM_LOCK, "NUM_LOCK" },
540  { SPICE_KEYBOARD_MODIFIER_FLAGS_CAPS_LOCK, "CAPS_LOCK" },
541  { 0, NULL } };
542 
543 typedef enum SpiceMouseButton {
544  SPICE_MOUSE_BUTTON_INVALID,
545  SPICE_MOUSE_BUTTON_LEFT,
546  SPICE_MOUSE_BUTTON_MIDDLE,
547  SPICE_MOUSE_BUTTON_RIGHT,
548  SPICE_MOUSE_BUTTON_UP,
549  SPICE_MOUSE_BUTTON_DOWN,
550 
551  SPICE_MOUSE_BUTTON_ENUM_END
552 } SpiceMouseButton;
553 
554 static const value_string spice_mouse_button_vs[] = {
555  { SPICE_MOUSE_BUTTON_INVALID, "INVALID" },
556  { SPICE_MOUSE_BUTTON_LEFT, "LEFT" },
557  { SPICE_MOUSE_BUTTON_MIDDLE, "MIDDLE" },
558  { SPICE_MOUSE_BUTTON_RIGHT, "RIGHT" },
559  { SPICE_MOUSE_BUTTON_UP, "UP" },
560  { SPICE_MOUSE_BUTTON_DOWN, "DOWN" },
561  { 0, NULL } };
562 
563 typedef enum SpiceMouseButtonMask {
564  SPICE_MOUSE_BUTTON_MASK_LEFT = (1 << 0),
565  SPICE_MOUSE_BUTTON_MASK_MIDDLE = (1 << 1),
566  SPICE_MOUSE_BUTTON_MASK_RIGHT = (1 << 2),
567 
568  SPICE_MOUSE_BUTTON_MASK_MASK = 0x7
569 } SpiceMouseButtonMask;
570 
571 static const value_string spice_mouse_button_mask_vs[] = {
572  { SPICE_MOUSE_BUTTON_MASK_LEFT, "LEFT" },
573  { SPICE_MOUSE_BUTTON_MASK_MIDDLE, "MIDDLE" },
574  { SPICE_MOUSE_BUTTON_MASK_RIGHT, "RIGHT" },
575  { 0, NULL } };
576 #endif
577 
578 typedef enum SpiceCursorType {
579  SPICE_CURSOR_TYPE_ALPHA,
580  SPICE_CURSOR_TYPE_MONO,
581  SPICE_CURSOR_TYPE_COLOR4,
582  SPICE_CURSOR_TYPE_COLOR8,
583  SPICE_CURSOR_TYPE_COLOR16,
584  SPICE_CURSOR_TYPE_COLOR24,
585  SPICE_CURSOR_TYPE_COLOR32,
586 
587  SPICE_CURSOR_TYPE_ENUM_END
588 } SpiceCursorType;
589 
590 static const value_string spice_cursor_type_vs[] = {
591  { SPICE_CURSOR_TYPE_ALPHA, "ALPHA" },
592  { SPICE_CURSOR_TYPE_MONO, "MONO" },
593  { SPICE_CURSOR_TYPE_COLOR4, "COLOR4" },
594  { SPICE_CURSOR_TYPE_COLOR8, "COLOR8" },
595  { SPICE_CURSOR_TYPE_COLOR16, "COLOR16" },
596  { SPICE_CURSOR_TYPE_COLOR24, "COLOR24" },
597  { SPICE_CURSOR_TYPE_COLOR32, "COLOR32" },
598  { 0, NULL } };
599 
600 typedef enum SpiceCursorFlags {
601  SPICE_CURSOR_FLAGS_NONE = (1 << 0),
602  SPICE_CURSOR_FLAGS_CACHE_ME = (1 << 1),
603  SPICE_CURSOR_FLAGS_FROM_CACHE = (1 << 2),
604 
605  SPICE_CURSOR_FLAGS_MASK = 0x7
606 } SpiceCursorFlags;
607 
608 static const value_string spice_cursor_flags_vs[] = {
609  { SPICE_CURSOR_FLAGS_NONE, "NONE" },
610  { SPICE_CURSOR_FLAGS_CACHE_ME, "CACHE_ME" },
611  { SPICE_CURSOR_FLAGS_FROM_CACHE, "FROM_CACHE" },
612  { 0, NULL } };
613 
614 typedef enum SpiceAudioDataMode {
615  SPICE_AUDIO_DATA_MODE_INVALID,
616  SPICE_AUDIO_DATA_MODE_RAW,
617  SPICE_AUDIO_DATA_MODE_CELT_0_5_1,
618 
619  SPICE_AUDIO_DATA_MODE_ENUM_END
620 } SpiceAudioDataMode;
621 
622 #if 0
623 static const value_string spice_audio_data_mode_vs[] = {
624  { SPICE_AUDIO_DATA_MODE_INVALID, "INVALID" },
625  { SPICE_AUDIO_DATA_MODE_RAW, "RAW" },
626  { SPICE_AUDIO_DATA_MODE_CELT_0_5_1, "CELT_0_5_1" },
627  { 0, NULL } };
628 #endif
629 
630 typedef enum SpiceAudioFmt {
631  SPICE_AUDIO_FMT_INVALID,
632  SPICE_AUDIO_FMT_S16,
633 
634  SPICE_AUDIO_FMT_ENUM_END
635 } SpiceAudioFmt;
636 
637 static const value_string spice_audio_fmt_vs[] = {
638  { SPICE_AUDIO_FMT_INVALID, "INVALID" },
639  { SPICE_AUDIO_FMT_S16, "S16" },
640  { 0, NULL } };
641 
642 #if 0
643 typedef enum SpiceTunnelServiceType {
644  SPICE_TUNNEL_SERVICE_TYPE_INVALID,
645  SPICE_TUNNEL_SERVICE_TYPE_GENERIC,
646  SPICE_TUNNEL_SERVICE_TYPE_IPP,
647 
648  SPICE_TUNNEL_SERVICE_TYPE_ENUM_END
649 } SpiceTunnelServiceType;
650 
651 static const value_string spice_tunnel_service_type_vs[] = {
652  { SPICE_TUNNEL_SERVICE_TYPE_INVALID, "INVALID" },
653  { SPICE_TUNNEL_SERVICE_TYPE_GENERIC, "GENERIC" },
654  { SPICE_TUNNEL_SERVICE_TYPE_IPP, "IPP" },
655  { 0, NULL } };
656 
657 typedef enum SpiceTunnelIpType {
658  SPICE_TUNNEL_IP_TYPE_INVALID,
659  SPICE_TUNNEL_IP_TYPE_IPV4,
660 
661  SPICE_TUNNEL_IP_TYPE_ENUM_END
662 } SpiceTunnelIpType;
663 
664 static const value_string spice_tunnel_ip_type_vs[] = {
665  { SPICE_TUNNEL_IP_TYPE_INVALID, "INVALID" },
666  { SPICE_TUNNEL_IP_TYPE_IPV4, "IPv4" },
667  { 0, NULL } };
668 
669 typedef enum SpiceVscMessageType {
670  SPICE_VSC_MESSAGE_TYPE_INIT = 1,
671  SPICE_VSC_MESSAGE_TYPE_ERROR,
672  SPICE_VSC_MESSAGE_TYPE_READERADD,
673  SPICE_VSC_MESSAGE_TYPE_READERREMOVE,
674  SPICE_VSC_MESSAGE_TYPE_ATR,
675  SPICE_VSC_MESSAGE_TYPE_CARDREMOVE,
676  SPICE_VSC_MESSAGE_TYPE_APDU,
677  SPICE_VSC_MESSAGE_TYPE_FLUSH,
678  SPICE_VSC_MESSAGE_TYPE_FLUSHCOMPLETE,
679 
680  SPICE_VSC_MESSAGE_TYPE_ENUM_END
681 } SpiceVscMessageType;
682 
683 static const value_string spice_vsc_message_type_vs[] = {
684  { SPICE_VSC_MESSAGE_TYPE_INIT, "Init" },
685  { SPICE_VSC_MESSAGE_TYPE_ERROR, "Error" },
686  { SPICE_VSC_MESSAGE_TYPE_READERADD, "ReaderAdd" },
687  { SPICE_VSC_MESSAGE_TYPE_READERREMOVE, "ReaderRemove" },
688  { SPICE_VSC_MESSAGE_TYPE_ATR, "ATR" },
689  { SPICE_VSC_MESSAGE_TYPE_CARDREMOVE, "CardRemove" },
690  { SPICE_VSC_MESSAGE_TYPE_APDU, "APDU" },
691  { SPICE_VSC_MESSAGE_TYPE_FLUSH, "Flush" },
692  { SPICE_VSC_MESSAGE_TYPE_FLUSHCOMPLETE, "FlushComplete" },
693  { 0, NULL } };
694 #endif
695 
696 enum {
697  SPICE_CHANNEL_MAIN = 1,
698  SPICE_CHANNEL_DISPLAY,
699  SPICE_CHANNEL_INPUTS,
700  SPICE_CHANNEL_CURSOR,
701  SPICE_CHANNEL_PLAYBACK,
702  SPICE_CHANNEL_RECORD,
703  SPICE_CHANNEL_TUNNEL,
704  SPICE_CHANNEL_SMARTCARD,
705  SPICE_CHANNEL_USBREDIR,
706  SPICE_CHANNEL_PORT,
707 
708  SPICE_END_CHANNEL
709 };
710 
711 static const value_string channel_types_vs[] = {
712  { SPICE_CHANNEL_MAIN, "MAIN" },
713  { SPICE_CHANNEL_DISPLAY, "DISPLAY" },
714  { SPICE_CHANNEL_INPUTS, "INPUTS" },
715  { SPICE_CHANNEL_CURSOR, "CURSOR" },
716  { SPICE_CHANNEL_PLAYBACK, "PLAYBACK" },
717  { SPICE_CHANNEL_RECORD, "RECORD" },
718  { SPICE_CHANNEL_TUNNEL, "TUNNEL" },
719  { SPICE_CHANNEL_SMARTCARD, "SMARTCARD" },
720  { SPICE_CHANNEL_USBREDIR, "USBREDIR" },
721  { SPICE_CHANNEL_PORT, "PORT" },
722 
723  { 0, NULL }
724 };
725 
726 enum {
727  SPICE_MSG_MIGRATE = 1,
728  SPICE_MSG_MIGRATE_DATA,
729  SPICE_MSG_SET_ACK,
730  SPICE_MSG_PING,
731  SPICE_MSG_WAIT_FOR_CHANNELS,
732  SPICE_MSG_DISCONNECTING,
733  SPICE_MSG_NOTIFY,
734  SPICE_MSG_LIST
735 };
736 
737 static const value_string spice_msg_vs[] = {
738  { SPICE_MSG_MIGRATE, "Server MIGRATE" },
739  { SPICE_MSG_MIGRATE_DATA, "Server MIGRATE_DATA" },
740  { SPICE_MSG_SET_ACK, "Server SET_ACK" },
741  { SPICE_MSG_PING, "Server PING" },
742  { SPICE_MSG_WAIT_FOR_CHANNELS, "Server WAIT_FOR_CHANNELS" },
743  { SPICE_MSG_DISCONNECTING, "Server DISCONNECTING" },
744  { SPICE_MSG_NOTIFY, "Server NOTIFY" },
745  { SPICE_MSG_LIST, "Server LIST" },
746  { 0, NULL }
747 };
748 
749 enum {
750  SPICE_MSGC_ACK_SYNC = 1,
751  SPICE_MSGC_ACK,
752  SPICE_MSGC_PONG,
753  SPICE_MSGC_MIGRATE_FLUSH_MARK,
754  SPICE_MSGC_MIGRATE_DATA,
755  SPICE_MSGC_DISCONNECTING
756 };
757 
758 static const value_string spice_msgc_vs[] = {
759  { SPICE_MSGC_ACK_SYNC, "Client ACK_SYNC" },
760  { SPICE_MSGC_ACK, "Client ACK" },
761  { SPICE_MSGC_PONG, "Client PONG" },
762  { SPICE_MSGC_MIGRATE_FLUSH_MARK, "Client MIGRATE_FLUSH_MARK" },
763  { SPICE_MSGC_MIGRATE_DATA, "Client MIGRATE_DATA" },
764  { SPICE_MSGC_DISCONNECTING, "Client DISCONNECTING" },
765  { 0, NULL }
766 };
767 
768 enum {
769  SPICE_MSG_MAIN_MIGRATE_BEGIN = 101,
770  SPICE_MSG_MAIN_MIGRATE_CANCEL,
771  SPICE_MSG_MAIN_INIT,
772  SPICE_MSG_MAIN_CHANNELS_LIST,
773  SPICE_MSG_MAIN_MOUSE_MODE,
774  SPICE_MSG_MAIN_MULTI_MEDIA_TIME,
775  SPICE_MSG_MAIN_AGENT_CONNECTED,
776  SPICE_MSG_MAIN_AGENT_DISCONNECTED,
777  SPICE_MSG_MAIN_AGENT_DATA,
778  SPICE_MSG_MAIN_AGENT_TOKEN,
779  SPICE_MSG_MAIN_MIGRATE_SWITCH_HOST,
780  SPICE_MSG_MAIN_MIGRATE_END,
781  SPICE_MSG_MAIN_NAME,
782  SPICE_MSG_MAIN_UUID,
783  SPICE_MSG_MAIN_AGENT_CONNECTED_TOKENS,
784  SPICE_MSG_MAIN_MIGRATE_BEGIN_SEAMLESS,
785  SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_ACK,
786  SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_NACK,
787 
788  SPICE_MSG_END_MAIN
789 };
790 
791 static const value_string spice_msg_main_vs[] = {
792  { SPICE_MSG_MAIN_MIGRATE_BEGIN, "Server MIGRATE_BEGIN" },
793  { SPICE_MSG_MAIN_MIGRATE_CANCEL, "Server MIGRATE_CANCEL" },
794  { SPICE_MSG_MAIN_INIT, "Server INIT" },
795  { SPICE_MSG_MAIN_CHANNELS_LIST, "Server CHANNELS_LIST" },
796  { SPICE_MSG_MAIN_MOUSE_MODE, "Server MOUSE_MODE" },
797  { SPICE_MSG_MAIN_MULTI_MEDIA_TIME, "Server MULTI_MEDIA_TIME" },
798  { SPICE_MSG_MAIN_AGENT_CONNECTED, "Server AGENT_CONNECTED" },
799  { SPICE_MSG_MAIN_AGENT_DISCONNECTED, "Server AGENT_DISCONNECTED" },
800  { SPICE_MSG_MAIN_AGENT_DATA, "Server AGENT_DATA" },
801  { SPICE_MSG_MAIN_AGENT_TOKEN, "Server AGENT_TOKEN" },
802  { SPICE_MSG_MAIN_MIGRATE_SWITCH_HOST, "Server MIGRATE_SWITCH_HOST" },
803  { SPICE_MSG_MAIN_MIGRATE_END, "Server MIGRATE_END" },
804  { SPICE_MSG_MAIN_NAME, "Server NAME" },
805  { SPICE_MSG_MAIN_UUID, "Server UUID" },
806  { SPICE_MSG_MAIN_AGENT_CONNECTED_TOKENS, "Server AGENT_CONNECTED_TOKENS" },
807  { SPICE_MSG_MAIN_MIGRATE_BEGIN_SEAMLESS, "Server MIGRATE_BEGIN_SEAMLESS" },
808  { SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_ACK, "Server MIGRATE_DST_SEAMLESS_ACK" },
809  { SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_NACK, "Server MIGRATE_DST_SEAMLESS_NACK" },
810  { 0, NULL }
811 };
812 
813 enum {
814  SPICE_MSGC_MAIN_CLIENT_INFO = 101,
815  SPICE_MSGC_MAIN_MIGRATE_CONNECTED,
816  SPICE_MSGC_MAIN_MIGRATE_CONNECT_ERROR,
817  SPICE_MSGC_MAIN_ATTACH_CHANNELS,
818  SPICE_MSGC_MAIN_MOUSE_MODE_REQUEST,
819  SPICE_MSGC_MAIN_AGENT_START,
820  SPICE_MSGC_MAIN_AGENT_DATA,
821  SPICE_MSGC_MAIN_AGENT_TOKEN,
822  SPICE_MSGC_MAIN_MIGRATE_END,
823  SPICE_MSGC_MAIN_MIGRATE_DST_DO_SEAMLESS,
824  SPICE_MSGC_MAIN_MIGRATE_CONNECTED_SEAMLESS,
825 
826  SPICE_MSGC_END_MAIN
827 };
828 
829 static const value_string spice_msgc_main_vs[] = {
830  { SPICE_MSGC_MAIN_CLIENT_INFO, "Client CLIENT_INFO" },
831  { SPICE_MSGC_MAIN_MIGRATE_CONNECTED, "Client MIGRATE_CONNECTED" },
832  { SPICE_MSGC_MAIN_MIGRATE_CONNECT_ERROR, "Client MIGRATE_CONNECT_ERROR" },
833  { SPICE_MSGC_MAIN_ATTACH_CHANNELS, "Client ATTACH_CHANNELS" },
834  { SPICE_MSGC_MAIN_MOUSE_MODE_REQUEST, "Client MOUSE_MODE_REQUEST" },
835  { SPICE_MSGC_MAIN_AGENT_START, "Client AGENT_START" },
836  { SPICE_MSGC_MAIN_AGENT_DATA, "Client AGENT_DATA" },
837  { SPICE_MSGC_MAIN_AGENT_TOKEN, "Client AGENT_TOKEN" },
838  { SPICE_MSGC_MAIN_MIGRATE_END, "Client MIGRATE_END" },
839  { SPICE_MSGC_MAIN_MIGRATE_DST_DO_SEAMLESS, "Client MIGRATE_DST_DO_SEAMLESS" },
840  { SPICE_MSGC_MAIN_MIGRATE_CONNECTED_SEAMLESS, "Client MIGRATE_CONNECTED_SEAMLESS" },
841  { 0, NULL }
842 };
843 
844 enum {
845  SPICE_MSG_DISPLAY_MODE = 101,
846  SPICE_MSG_DISPLAY_MARK,
847  SPICE_MSG_DISPLAY_RESET,
848  SPICE_MSG_DISPLAY_COPY_BITS,
849  SPICE_MSG_DISPLAY_INVAL_LIST,
850  SPICE_MSG_DISPLAY_INVAL_ALL_PIXMAPS,
851  SPICE_MSG_DISPLAY_INVAL_PALETTE,
852  SPICE_MSG_DISPLAY_INVAL_ALL_PALETTES,
853  SPICE_MSG_DISPLAY_STREAM_CREATE = 122,
854  SPICE_MSG_DISPLAY_STREAM_DATA,
855  SPICE_MSG_DISPLAY_STREAM_CLIP,
856  SPICE_MSG_DISPLAY_STREAM_DESTROY,
857  SPICE_MSG_DISPLAY_STREAM_DESTROY_ALL,
858  SPICE_MSG_DISPLAY_DRAW_FILL = 302,
859  SPICE_MSG_DISPLAY_DRAW_OPAQUE,
860  SPICE_MSG_DISPLAY_DRAW_COPY,
861  SPICE_MSG_DISPLAY_DRAW_BLEND,
862  SPICE_MSG_DISPLAY_DRAW_BLACKNESS,
863  SPICE_MSG_DISPLAY_DRAW_WHITENESS,
864  SPICE_MSG_DISPLAY_DRAW_INVERS,
865  SPICE_MSG_DISPLAY_DRAW_ROP3,
866  SPICE_MSG_DISPLAY_DRAW_STROKE,
867  SPICE_MSG_DISPLAY_DRAW_TEXT,
868  SPICE_MSG_DISPLAY_DRAW_TRANSPARENT,
869  SPICE_MSG_DISPLAY_DRAW_ALPHA_BLEND,
870  SPICE_MSG_DISPLAY_SURFACE_CREATE,
871  SPICE_MSG_DISPLAY_SURFACE_DESTROY,
872  SPICE_MSG_DISPLAY_STREAM_DATA_SIZED,
873  SPICE_MSG_DISPLAY_MONITORS_CONFIG,
874  SPICE_MSG_DISPLAY_DRAW_COMPOSITE,
875  SPICE_MSG_DISPLAY_STREAM_ACTIVATE_REPORT,
876 
877  SPICE_MSG_END_DISPLAY
878 };
879 
880 static const value_string spice_msg_display_vs[] = {
881  { SPICE_MSG_DISPLAY_MODE, "Server MODE" },
882  { SPICE_MSG_DISPLAY_MARK, "Server MARK" },
883  { SPICE_MSG_DISPLAY_RESET, "Server RESET" },
884  { SPICE_MSG_DISPLAY_COPY_BITS, "Server COPY_BITS" },
885  { SPICE_MSG_DISPLAY_INVAL_LIST, "Server INVAL_LIST" },
886  { SPICE_MSG_DISPLAY_INVAL_ALL_PIXMAPS, "Server INVAL_ALL_PIXMAPS" },
887  { SPICE_MSG_DISPLAY_INVAL_PALETTE, "Server INVAL_PALETTE" },
888  { SPICE_MSG_DISPLAY_INVAL_ALL_PALETTES, "Server INVAL_ALL_PALETTES" },
889  { SPICE_MSG_DISPLAY_STREAM_CREATE, "Server STREAM_CREATE" },
890  { SPICE_MSG_DISPLAY_STREAM_DATA, "Server STREAM_DATA" },
891  { SPICE_MSG_DISPLAY_STREAM_CLIP, "Server STREAM_CLIP" },
892  { SPICE_MSG_DISPLAY_STREAM_DESTROY, "Server STREAM_DESTROY" },
893  { SPICE_MSG_DISPLAY_STREAM_DESTROY_ALL, "Server STREAM_DESTROY_ALL" },
894  { SPICE_MSG_DISPLAY_DRAW_FILL, "Server DRAW_FILL" },
895  { SPICE_MSG_DISPLAY_DRAW_OPAQUE, "Server DRAW_OPAQUE" },
896  { SPICE_MSG_DISPLAY_DRAW_COPY, "Server DRAW_COPY" },
897  { SPICE_MSG_DISPLAY_DRAW_BLEND, "Server DRAW_BLEND" },
898  { SPICE_MSG_DISPLAY_DRAW_BLACKNESS, "Server DRAW_BLACKNESS" },
899  { SPICE_MSG_DISPLAY_DRAW_WHITENESS, "Server DRAW_WHITENESS" },
900  { SPICE_MSG_DISPLAY_DRAW_INVERS, "Server DRAW_INVERS" },
901  { SPICE_MSG_DISPLAY_DRAW_ROP3, "Server DRAW_ROP3" },
902  { SPICE_MSG_DISPLAY_DRAW_STROKE, "Server DRAW_STROKE" },
903  { SPICE_MSG_DISPLAY_DRAW_TEXT, "Server DRAW_TEXT" },
904  { SPICE_MSG_DISPLAY_DRAW_TRANSPARENT, "Server DRAW_TRANSPARENT" },
905  { SPICE_MSG_DISPLAY_DRAW_ALPHA_BLEND, "Server DRAW_ALPHA_BLEND" },
906  { SPICE_MSG_DISPLAY_SURFACE_CREATE, "Server SURFACE_CREATE" },
907  { SPICE_MSG_DISPLAY_SURFACE_DESTROY, "Server SURFACE_DESTROY" },
908  { SPICE_MSG_DISPLAY_STREAM_DATA_SIZED, "Server STREAM_DATA_SIZED" },
909  { SPICE_MSG_DISPLAY_MONITORS_CONFIG, "Server MONITORS_CONFIG" },
910  { SPICE_MSG_DISPLAY_DRAW_COMPOSITE, "Server DRAW_COMPOSITE" },
911  { SPICE_MSG_DISPLAY_STREAM_ACTIVATE_REPORT, "Server STREAM_ACTIVATE_REPORT" },
912  { 0, NULL }
913 };
914 
915 enum {
916  SPICE_MSGC_DISPLAY_INIT = 101,
917  SPICE_MSGC_DISPLAY_STREAM_REPORT,
918 
919  SPICE_MSGC_END_DISPLAY
920 };
921 
922 static const value_string spice_msgc_display_vs[] = {
923  { SPICE_MSGC_DISPLAY_INIT, "Client INIT" },
924  { SPICE_MSGC_DISPLAY_STREAM_REPORT, "Client STREAM_REPORT" },
925  { 0, NULL }
926 };
927 
928 enum {
929  SPICE_MSG_INPUTS_INIT = 101,
930  SPICE_MSG_INPUTS_KEY_MODIFIERS,
931  SPICE_MSG_INPUTS_MOUSE_MOTION_ACK = 111,
932 
933  SPICE_MSG_END_INPUTS
934 };
935 
936 static const value_string spice_msg_inputs_vs[] = {
937  { SPICE_MSG_INPUTS_INIT, "Server INIT" },
938  { SPICE_MSG_INPUTS_KEY_MODIFIERS, "Server KEY_MODIFIERS" },
939  { SPICE_MSG_INPUTS_MOUSE_MOTION_ACK, "Server MOUSE_MOTION_ACK" },
940  { 0, NULL }
941 };
942 
943 enum {
944  SPICE_MSGC_INPUTS_KEY_DOWN = 101,
945  SPICE_MSGC_INPUTS_KEY_UP,
946  SPICE_MSGC_INPUTS_KEY_MODIFIERS,
947  SPICE_MSGC_INPUTS_KEY_SCANCODE,
948  SPICE_MSGC_INPUTS_MOUSE_MOTION = 111,
949  SPICE_MSGC_INPUTS_MOUSE_POSITION,
950  SPICE_MSGC_INPUTS_MOUSE_PRESS,
951  SPICE_MSGC_INPUTS_MOUSE_RELEASE,
952 
953  SPICE_MSGC_END_INPUTS
954 };
955 
956 static const value_string spice_msgc_inputs_vs[] = {
957  { SPICE_MSGC_INPUTS_KEY_DOWN, "Client KEY_DOWN" },
958  { SPICE_MSGC_INPUTS_KEY_UP, "Client KEY_UP" },
959  { SPICE_MSGC_INPUTS_KEY_MODIFIERS, "Client KEY_MODIFIERS" },
960  { SPICE_MSGC_INPUTS_KEY_SCANCODE, "Client KEY_SCANCODE" },
961  { SPICE_MSGC_INPUTS_MOUSE_MOTION, "Client MOUSE_MOTION" },
962  { SPICE_MSGC_INPUTS_MOUSE_POSITION, "Client MOUSE_POSITION" },
963  { SPICE_MSGC_INPUTS_MOUSE_PRESS, "Client MOUSE_PRESS" },
964  { SPICE_MSGC_INPUTS_MOUSE_RELEASE, "Client MOUSE_RELEASE" },
965  { 0, NULL }
966 };
967 
968 enum {
969  SPICE_MSG_CURSOR_INIT = 101,
970  SPICE_MSG_CURSOR_RESET,
971  SPICE_MSG_CURSOR_SET,
972  SPICE_MSG_CURSOR_MOVE,
973  SPICE_MSG_CURSOR_HIDE,
974  SPICE_MSG_CURSOR_TRAIL,
975  SPICE_MSG_CURSOR_INVAL_ONE,
976  SPICE_MSG_CURSOR_INVAL_ALL,
977 
978  SPICE_MSG_END_CURSOR
979 };
980 
981 static const value_string spice_msg_cursor_vs[] = {
982  { SPICE_MSG_CURSOR_INIT, "Server INIT" },
983  { SPICE_MSG_CURSOR_RESET, "Server RESET" },
984  { SPICE_MSG_CURSOR_SET, "Server SET" },
985  { SPICE_MSG_CURSOR_MOVE, "Server MOVE" },
986  { SPICE_MSG_CURSOR_HIDE, "Server HIDE" },
987  { SPICE_MSG_CURSOR_TRAIL, "Server TRAIL" },
988  { SPICE_MSG_CURSOR_INVAL_ONE, "Server INVAL_ONE" },
989  { SPICE_MSG_CURSOR_INVAL_ALL, "Server INVAL_ALL" },
990  { 0, NULL }
991 };
992 
993 enum {
994  SPICE_MSG_PLAYBACK_DATA = 101,
995  SPICE_MSG_PLAYBACK_MODE,
996  SPICE_MSG_PLAYBACK_START,
997  SPICE_MSG_PLAYBACK_STOP,
998  SPICE_MSG_PLAYBACK_VOLUME,
999  SPICE_MSG_PLAYBACK_MUTE,
1000  SPICE_MSG_PLAYBACK_LATENCY,
1001 
1002  SPICE_MSG_END_PLAYBACK
1003 };
1004 
1005 static const value_string spice_msg_playback_vs[] = {
1006  { SPICE_MSG_PLAYBACK_DATA, "Server DATA" },
1007  { SPICE_MSG_PLAYBACK_MODE, "Server MODE" },
1008  { SPICE_MSG_PLAYBACK_START, "Server START" },
1009  { SPICE_MSG_PLAYBACK_STOP, "Server STOP" },
1010  { SPICE_MSG_PLAYBACK_VOLUME, "Server VOLUME" },
1011  { SPICE_MSG_PLAYBACK_MUTE, "Server MUTE" },
1012  { SPICE_MSG_PLAYBACK_LATENCY, "Server LATENCY" },
1013  { 0, NULL }
1014 };
1015 
1016 enum {
1017  SPICE_MSG_RECORD_START = 101,
1018  SPICE_MSG_RECORD_STOP,
1019  SPICE_MSG_RECORD_VOLUME,
1020  SPICE_MSG_RECORD_MUTE,
1021 
1022  SPICE_MSG_END_RECORD
1023 };
1024 
1025 static const value_string spice_msg_record_vs[] = {
1026  { SPICE_MSG_RECORD_START, "Server START" },
1027  { SPICE_MSG_RECORD_STOP, "Server STOP" },
1028  { SPICE_MSG_RECORD_VOLUME, "Server VOLUME" },
1029  { SPICE_MSG_RECORD_MUTE, "Server MUTE" },
1030  { 0, NULL }
1031 };
1032 
1033 enum {
1034  SPICE_MSGC_RECORD_DATA = 101,
1035  SPICE_MSGC_RECORD_MODE,
1036  SPICE_MSGC_RECORD_START_MARK,
1037 
1038  SPICE_MSGC_END_RECORD
1039 };
1040 
1041 static const value_string spice_msgc_record_vs[] = {
1042  { SPICE_MSGC_RECORD_DATA, "Client DATA" },
1043  { SPICE_MSGC_RECORD_MODE, "Client MODE" },
1044  { SPICE_MSGC_RECORD_START_MARK, "Client START_MARK" },
1045  { 0, NULL }
1046 };
1047 
1048 enum {
1049  SPICE_MSG_TUNNEL_INIT = 101,
1050  SPICE_MSG_TUNNEL_SERVICE_IP_MAP,
1051  SPICE_MSG_TUNNEL_SOCKET_OPEN,
1052  SPICE_MSG_TUNNEL_SOCKET_FIN,
1053  SPICE_MSG_TUNNEL_SOCKET_CLOSE,
1054  SPICE_MSG_TUNNEL_SOCKET_DATA,
1055  SPICE_MSG_TUNNEL_SOCKET_CLOSED_ACK,
1056  SPICE_MSG_TUNNEL_SOCKET_TOKEN,
1057 
1058  SPICE_MSG_END_TUNNEL
1059 };
1060 
1061 static const value_string spice_msg_tunnel_vs[] = {
1062  { SPICE_MSG_TUNNEL_INIT, "Server INIT" },
1063  { SPICE_MSG_TUNNEL_SERVICE_IP_MAP, "Server SERVICE_IP_MAP" },
1064  { SPICE_MSG_TUNNEL_SOCKET_OPEN, "Server SOCKET_OPEN" },
1065  { SPICE_MSG_TUNNEL_SOCKET_FIN, "Server SOCKET_FIN" },
1066  { SPICE_MSG_TUNNEL_SOCKET_CLOSE, "Server SOCKET_CLOSE" },
1067  { SPICE_MSG_TUNNEL_SOCKET_DATA, "Server SOCKET_DATA" },
1068  { SPICE_MSG_TUNNEL_SOCKET_CLOSED_ACK, "Server SOCKET_CLOSED_ACK" },
1069  { SPICE_MSG_TUNNEL_SOCKET_TOKEN, "Server SOCKET_TOKEN" },
1070  { 0, NULL }
1071 };
1072 
1073 enum {
1074  SPICE_MSGC_TUNNEL_SERVICE_ADD = 101,
1075  SPICE_MSGC_TUNNEL_SERVICE_REMOVE,
1076  SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK,
1077  SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK,
1078  SPICE_MSGC_TUNNEL_SOCKET_FIN,
1079  SPICE_MSGC_TUNNEL_SOCKET_CLOSED,
1080  SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK,
1081  SPICE_MSGC_TUNNEL_SOCKET_DATA,
1082  SPICE_MSGC_TUNNEL_SOCKET_TOKEN,
1083 
1084  SPICE_MSGC_END_TUNNEL
1085 };
1086 
1087 static const value_string spice_msgc_tunnel_vs[] = {
1088  { SPICE_MSGC_TUNNEL_SERVICE_ADD, "Client SERVICE_ADD" },
1089  { SPICE_MSGC_TUNNEL_SERVICE_REMOVE, "Client SERVICE_REMOVE" },
1090  { SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK, "Client SOCKET_OPEN_ACK" },
1091  { SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK, "Client SOCKET_OPEN_NACK" },
1092  { SPICE_MSGC_TUNNEL_SOCKET_FIN, "Client SOCKET_FIN" },
1093  { SPICE_MSGC_TUNNEL_SOCKET_CLOSED, "Client SOCKET_CLOSED" },
1094  { SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK, "Client SOCKET_CLOSED_ACK" },
1095  { SPICE_MSGC_TUNNEL_SOCKET_DATA, "Client SOCKET_DATA" },
1096  { SPICE_MSGC_TUNNEL_SOCKET_TOKEN, "Client SOCKET_TOKEN" },
1097  { 0, NULL }
1098 };
1099 
1100 enum {
1101  SPICE_MSG_SMARTCARD_DATA = 101,
1102 
1103  SPICE_MSG_END_SMARTCARD
1104 };
1105 
1106 static const value_string spice_msg_smartcard_vs[] = {
1107  { SPICE_MSG_SMARTCARD_DATA, "Server DATA" },
1108  { 0, NULL }
1109 };
1110 
1111 enum {
1112  SPICE_MSGC_SMARTCARD_DATA = 101,
1113  SPICE_MSGC_SMARTCARD_HEADER = 101,
1114  SPICE_MSGC_SMARTCARD_ERROR = 101,
1115  SPICE_MSGC_SMARTCARD_ATR = 101,
1116  SPICE_MSGC_SMARTCARD_READER_ADD = 101,
1117 
1118  SPICE_MSGC_END_SMARTCARD
1119 };
1120 
1121 static const value_string spice_msgc_smartcard_vs[] = {
1122  { SPICE_MSGC_SMARTCARD_DATA, "Client DATA" },
1123  { SPICE_MSGC_SMARTCARD_HEADER, "Client HEADER" },
1124  { SPICE_MSGC_SMARTCARD_ERROR, "Client ERROR" },
1125  { SPICE_MSGC_SMARTCARD_ATR, "Client ATR" },
1126  { SPICE_MSGC_SMARTCARD_READER_ADD, "Client READER_ADD" },
1127  { 0, NULL }
1128 };
1129 
1130 enum {
1131  SPICE_MSG_SPICEVMC_DATA = 101,
1132 
1133  SPICE_MSG_END_SPICEVMC
1134 };
1135 
1136 static const value_string spice_msg_spicevmc_vs[] = {
1137  { SPICE_MSG_SPICEVMC_DATA, "Server DATA" },
1138  { 0, NULL }
1139 };
1140 
1141 enum {
1142  SPICE_MSGC_SPICEVMC_DATA = 101,
1143 
1144  SPICE_MSGC_END_SPICEVMC
1145 };
1146 
1147 static const value_string spice_msgc_spicevmc_vs[] = {
1148  { SPICE_MSGC_SPICEVMC_DATA, "Client DATA" },
1149  { 0, NULL }
1150 };
1151 
1152 enum {
1153  SPICE_MSG_PORT_INIT = 201,
1154  SPICE_MSG_PORT_EVENT,
1155 
1156  SPICE_MSG_END_PORT
1157 };
1158 
1159 #if 0
1160 static const value_string spice_msg_port_vs[] = {
1161  { SPICE_MSG_PORT_INIT, "Server INIT" },
1162  { SPICE_MSG_PORT_EVENT, "Server EVENT" },
1163  { 0, NULL }
1164 };
1165 #endif
1166 
1167 enum {
1168  SPICE_MSGC_PORT_EVENT = 201,
1169 
1170  SPICE_MSGC_END_PORT
1171 };
1172 
1173 #if 0
1174 static const value_string spice_msgc_port_vs[] = {
1175  { SPICE_MSGC_PORT_EVENT, "Client EVENT" },
1176  { 0, NULL }
1177 };
1178 #endif
1179 
1180 #endif /* _H_SPICE_ENUMS */
Definition: value_string.h:24