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