Wireshark 2.9.0-477-g68ec514b The Wireshark network protocol analyzer

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

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 */
_value_string
Definition: value_string.h:24