diff options
Diffstat (limited to 'epan/dissectors/packet-vnc.c')
| -rw-r--r-- | epan/dissectors/packet-vnc.c | 4925 |
1 files changed, 4925 insertions, 0 deletions
diff --git a/epan/dissectors/packet-vnc.c b/epan/dissectors/packet-vnc.c new file mode 100644 index 00000000..d0e12b86 --- /dev/null +++ b/epan/dissectors/packet-vnc.c @@ -0,0 +1,4925 @@ +/* packet-vnc.c + * Routines for VNC dissection (Virtual Network Computing) + * Copyright 2005, Ulf Lamping <ulf.lamping@web.de> + * Copyright 2006-2007, Stephen Fisher (see AUTHORS file) + * + * Wireshark - Network traffic analyzer + * By Gerald Combs <gerald@wireshark.org> + * Copyright 1998 Gerald Combs + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + +/* Dissection of the VNC (Virtual Network Computing) network traffic. + * + * All versions of RealVNC and TightVNC are supported. + * Note: The addition of TightVNC support is not yet complete. + * + * Several VNC implementations available, see: + * http://www.realvnc.com/ + * http://www.tightvnc.com/ + * http://ultravnc.sourceforge.net/ + * [Fedora TigerVNC] + * ... + * + * The protocol itself is known as RFB - Remote Frame Buffer Protocol. + * + * This code is based on the protocol specification: + * http://www.realvnc.com/docs/rfbproto.pdf + * and the RealVNC free edition & TightVNC source code + * Note: rfbproto.rst [ https://github.com/svn2github/tigervnc/blob/master/rfbproto/rfbproto.rst ] + * seems to have additional information over rfbproto.pdf. + */ + +/* XXX: + * This dissector adds items to the protocol tree before completing re-assembly + * of a VNC PDU which extends over more than one TCP segment. + * This is not correct. As noted in Bug #5366 (and elsewhere), the correct method + * is that: + * "one must walk over all the message first, to determine its exact length + * (one of the characteristics of the protocol, hard to determine prior to + * going over the message what its final size would be)". + * + * The original method of reassembly: + * When more data is needed to continue dissecting a PDU, repeatedly request + * a few additional bytes (for one or a few more fields of the PDU). + * This resulted in 'one-pass' tshark dissection redissecting + * the PDU repeatedly many, many times with each time dissecting + * the PDU with one or a few more additional fields. + * This generated *lots* of (repeated) output since a reassembled + * VNC PDU can contain many fields (each of short length). + * It also resulted in the fragment table containing many, many small fragments + * for VNC PDUS containing many small fields. + * + * The current reassembly method: + * Use DESEGMENT_ONE_MORE_SEGMENT when requesting additional data for a PDU. + * This significantly reduces the amount of repeated data in a dissection, + * but will still result in "partial" repeated dissection output in some cases. + */ + +/* (Somewhat random notes while reviewing the code): + Check types, etc against IANA list + Optimize: Do col_set(..., COL_INFO) once (after fetching message type & before dispatching ?) + Dispatch via a message table (instead of using a switch(...) + Worry about globals (vnc_bytes_per_pixel & nc_depth): "Global so they keep their value between packets" + Msg type 150: client-server: enable/disable (1+9 bytes); server-client: endofContinousUpdates(1+0 bytes) ? +*/ + +#include "config.h" + +#include <epan/packet.h> +#include <epan/conversation.h> +#include <epan/prefs.h> +#include <epan/expert.h> +#include <epan/proto_data.h> +#include "packet-x11.h" /* This contains the extern for the X11 value_string_ext + * "x11_keysym_vals_source_ext" that VNC uses. */ + +void proto_register_vnc(void); + +typedef enum { + VNC_SECURITY_TYPE_INVALID = 0, + VNC_SECURITY_TYPE_NONE = 1, + VNC_SECURITY_TYPE_VNC = 2, + VNC_SECURITY_TYPE_RA2 = 5, + VNC_SECURITY_TYPE_RA2ne = 6, + VNC_SECURITY_TYPE_TIGHT = 16, + VNC_SECURITY_TYPE_ULTRA = 17, + VNC_SECURITY_TYPE_TLS = 18, + VNC_SECURITY_TYPE_VENCRYPT = 19, + VNC_SECURITY_TYPE_GTK_VNC_SASL = 20, + VNC_SECURITY_TYPE_MD5_HASH_AUTH = 21, + VNC_SECURITY_TYPE_XVP = 22, + VNC_SECURITY_TYPE_ARD = 30, + VNC_TIGHT_AUTH_TGHT_ULGNAUTH = 119, + VNC_TIGHT_AUTH_TGHT_XTRNAUTH = 130, + VNC_VENCRYPT_AUTH_PLAIN = 256, + VNC_VENCRYPT_AUTH_TLSNONE = 257, + VNC_VENCRYPT_AUTH_TLSVNC = 258, + VNC_VENCRYPT_AUTH_TLSPLAIN = 259, + VNC_VENCRYPT_AUTH_X509_NONE = 260, + VNC_VENCRYPT_AUTH_X509_VNC = 261, + VNC_VENCRYPT_AUTH_X509_PLAIN = 262, + VNC_VENCRYPT_AUTH_TLSSASL = 263, + VNC_VENCRYPT_AUTH_X509_SASL = 264 +} vnc_security_types_e; + +static const value_string vnc_security_types_vs[] = { + { VNC_SECURITY_TYPE_INVALID, "Invalid" }, + { VNC_SECURITY_TYPE_NONE, "None" }, + { VNC_SECURITY_TYPE_VNC, "VNC" }, + { VNC_SECURITY_TYPE_RA2, "RA2" }, + { VNC_SECURITY_TYPE_RA2ne, "RA2ne" }, + { VNC_SECURITY_TYPE_TIGHT, "Tight" }, + { VNC_SECURITY_TYPE_ULTRA, "Ultra" }, + { VNC_SECURITY_TYPE_TLS, "TLS" }, + { VNC_SECURITY_TYPE_VENCRYPT, "VeNCrypt" }, + { VNC_SECURITY_TYPE_GTK_VNC_SASL, "GTK-VNC SASL" }, + { VNC_SECURITY_TYPE_ARD, "Apple Remote Desktop" }, + { 0, NULL } +}; + +static const value_string vnc_vencrypt_auth_types_vs[] = { + { VNC_SECURITY_TYPE_NONE, "None" }, + { VNC_SECURITY_TYPE_VNC, "VNC" }, + { VNC_VENCRYPT_AUTH_PLAIN, "Plain" }, + { VNC_VENCRYPT_AUTH_TLSNONE, "TLS None" }, + { VNC_VENCRYPT_AUTH_TLSVNC, "TLS VNC" }, + { VNC_VENCRYPT_AUTH_TLSPLAIN, "TLS Plain" }, + { VNC_VENCRYPT_AUTH_X509_NONE, "X.509 None" }, + { VNC_VENCRYPT_AUTH_X509_VNC, "X.509 VNC" }, + { VNC_VENCRYPT_AUTH_X509_PLAIN, "X.509 Plain" }, + { VNC_VENCRYPT_AUTH_TLSSASL, "TLS SASL" }, + { VNC_VENCRYPT_AUTH_X509_SASL, "X.509 SASL" }, + { 0, NULL } +}; + +static const true_false_string auth_result_tfs = { + "Failed", + "OK" +}; + +typedef enum { + /* Required */ + VNC_CLIENT_MESSAGE_TYPE_SET_PIXEL_FORMAT = 0, + VNC_CLIENT_MESSAGE_TYPE_SET_ENCODINGS = 2, + VNC_CLIENT_MESSAGE_TYPE_FRAMEBUF_UPDATE_REQ = 3, + VNC_CLIENT_MESSAGE_TYPE_KEY_EVENT = 4, + VNC_CLIENT_MESSAGE_TYPE_POINTER_EVENT = 5, + VNC_CLIENT_MESSAGE_TYPE_CLIENT_CUT_TEXT = 6, + /* Optional */ + VNC_CLIENT_MESSAGE_TYPE_MIRRORLINK = 128, + VNC_CLIENT_MESSAGE_TYPE_ENABLE_CONTINUOUS_UPDATES = 150, /* TightVNC */ + VNC_CLIENT_MESSAGE_TYPE_FENCE = 248, /* TigerVNC */ + VNC_CLIENT_MESSAGE_TYPE_XVP = 250, + VNC_CLIENT_MESSAGE_TYPE_SETR_DESKTOP_SIZE = 251, + VNC_CLIENT_MESSAGE_TYPE_TIGHT = 252, + VNC_CLIENT_MESSAGE_TYPE_GII = 253, + VNC_CLIENT_MESSAGE_TYPE_QEMU = 255 +} vnc_client_message_types_e; + +static const value_string vnc_client_message_types_vs[] = { + /* Required */ + { VNC_CLIENT_MESSAGE_TYPE_SET_PIXEL_FORMAT, "Set Pixel Format" }, + { VNC_CLIENT_MESSAGE_TYPE_SET_ENCODINGS, "Set Encodings" }, + { VNC_CLIENT_MESSAGE_TYPE_FRAMEBUF_UPDATE_REQ, "Framebuffer Update Request" }, + { VNC_CLIENT_MESSAGE_TYPE_KEY_EVENT, "Key Event" }, + { VNC_CLIENT_MESSAGE_TYPE_POINTER_EVENT, "Pointer Event" }, + { VNC_CLIENT_MESSAGE_TYPE_CLIENT_CUT_TEXT, "Cut Text" }, + /* Optional */ + { VNC_CLIENT_MESSAGE_TYPE_MIRRORLINK, "MirrorLink" }, + { VNC_CLIENT_MESSAGE_TYPE_ENABLE_CONTINUOUS_UPDATES, "Enable Continuous Updates" }, + { VNC_CLIENT_MESSAGE_TYPE_FENCE, "Fence" }, + { VNC_CLIENT_MESSAGE_TYPE_XVP, "Xvp" }, + { VNC_CLIENT_MESSAGE_TYPE_SETR_DESKTOP_SIZE, "Setr Desktop Size" }, + { VNC_CLIENT_MESSAGE_TYPE_TIGHT, "Tight" }, + { VNC_CLIENT_MESSAGE_TYPE_GII, "Gii" }, + { VNC_CLIENT_MESSAGE_TYPE_QEMU, "Qemu" }, + { 0, NULL } +}; + +typedef enum { + VNC_SERVER_MESSAGE_TYPE_FRAMEBUFFER_UPDATE = 0, + VNC_SERVER_MESSAGE_TYPE_SET_COLORMAP_ENTRIES = 1, + VNC_SERVER_MESSAGE_TYPE_RING_BELL = 2, + VNC_SERVER_MESSAGE_TYPE_CUT_TEXT = 3, + VNC_SERVER_MESSAGE_TYPE_MIRRORLINK = 128, + VNC_SERVER_MESSAGE_TYPE_END_CONTINUOUS_UPDATES = 150, /* TightVNC */ + VNC_SERVER_MESSAGE_TYPE_FENCE = 248, /* TigerVNC */ + VNC_SERVER_MESSAGE_TYPE_XVP = 250, + VNC_SERVER_MESSAGE_TYPE_TIGHT = 252, + VNC_SERVER_MESSAGE_TYPE_GII = 253, + VNC_SERVER_MESSAGE_TYPE_QEMU = 255 +} vnc_server_message_types_e; + +static const value_string vnc_server_message_types_vs[] = { + { VNC_SERVER_MESSAGE_TYPE_FRAMEBUFFER_UPDATE, "Framebuffer Update" }, + { VNC_SERVER_MESSAGE_TYPE_SET_COLORMAP_ENTRIES, "Set Colormap Entries" }, + { VNC_SERVER_MESSAGE_TYPE_RING_BELL, "Ring Bell" }, + { VNC_SERVER_MESSAGE_TYPE_CUT_TEXT, "Cut Text" }, + { VNC_SERVER_MESSAGE_TYPE_MIRRORLINK, "MirrorLink" }, + { VNC_SERVER_MESSAGE_TYPE_END_CONTINUOUS_UPDATES, "End Continuous Updates" }, + { VNC_SERVER_MESSAGE_TYPE_FENCE, "Fence" }, + { VNC_SERVER_MESSAGE_TYPE_XVP, "Xvp" }, + { VNC_SERVER_MESSAGE_TYPE_TIGHT, "Tight" }, + { VNC_SERVER_MESSAGE_TYPE_GII, "Gii" }, + { VNC_SERVER_MESSAGE_TYPE_QEMU, "Qemu" }, + { 0, NULL } +}; + + +#define VNC_ENCODING_TYPE_DESKTOP_SIZE 0xFFFFFF21 +#define VNC_ENCODING_TYPE_LAST_RECT 0xFFFFFF20 +#define VNC_ENCODING_TYPE_POINTER_POS 0xFFFFFF18 +#define VNC_ENCODING_TYPE_RICH_CURSOR 0xFFFFFF11 +#define VNC_ENCODING_TYPE_X_CURSOR 0xFFFFFF10 +#define VNC_ENCODING_TYPE_RAW 0 +#define VNC_ENCODING_TYPE_COPY_RECT 1 +#define VNC_ENCODING_TYPE_RRE 2 +#define VNC_ENCODING_TYPE_CORRE 4 +#define VNC_ENCODING_TYPE_HEXTILE 5 +#define VNC_ENCODING_TYPE_ZLIB 6 +#define VNC_ENCODING_TYPE_TIGHT 7 +#define VNC_ENCODING_TYPE_ZLIBHEX 8 +#define VNC_ENCODING_TYPE_ULTRA 9 +#define VNC_ENCODING_TYPE_TRLE 15 +#define VNC_ENCODING_TYPE_RLE 16 +#define VNC_ENCODING_TYPE_HITACHI_ZYWRLE 17 +#define VNC_ENCODING_TYPE_JPEG_0 -32 +#define VNC_ENCODING_TYPE_JPEG_1 -31 +#define VNC_ENCODING_TYPE_JPEG_2 -30 +#define VNC_ENCODING_TYPE_JPEG_3 -29 +#define VNC_ENCODING_TYPE_JPEG_4 -28 +#define VNC_ENCODING_TYPE_JPEG_5 -27 +#define VNC_ENCODING_TYPE_JPEG_6 -26 +#define VNC_ENCODING_TYPE_JPEG_7 -25 +#define VNC_ENCODING_TYPE_JPEG_8 -24 +#define VNC_ENCODING_TYPE_JPEG_9 -23 +#define VNC_ENCODING_TYPE_COMPRESSION_0 0xFFFFFF00 +#define VNC_ENCODING_TYPE_COMPRESSION_1 0xFFFFFF01 +#define VNC_ENCODING_TYPE_COMPRESSION_2 0xFFFFFF02 +#define VNC_ENCODING_TYPE_COMPRESSION_3 0xFFFFFF03 +#define VNC_ENCODING_TYPE_COMPRESSION_4 0xFFFFFF04 +#define VNC_ENCODING_TYPE_COMPRESSION_5 0xFFFFFF05 +#define VNC_ENCODING_TYPE_COMPRESSION_6 0xFFFFFF06 +#define VNC_ENCODING_TYPE_COMPRESSION_7 0xFFFFFF07 +#define VNC_ENCODING_TYPE_COMPRESSION_8 0xFFFFFF08 +#define VNC_ENCODING_TYPE_COMPRESSION_9 0xFFFFFF09 +#define VNC_ENCODING_TYPE_WMVi 0x574D5669 +#define VNC_ENCODING_TYPE_CACHE 0xFFFF0000 +#define VNC_ENCODING_TYPE_CACHE_ENABLE 0xFFFF0001 +#define VNC_ENCODING_TYPE_XOR_ZLIB 0xFFFF0002 +#define VNC_ENCODING_TYPE_XOR_MONO_ZLIB 0xFFFF0003 +#define VNC_ENCODING_TYPE_XOR_MULTI_ZLIB 0xFFFF0004 +#define VNC_ENCODING_TYPE_SOLID_COLOR 0xFFFF0005 +#define VNC_ENCODING_TYPE_XOR_ENABLE 0xFFFF0006 +#define VNC_ENCODING_TYPE_CACHE_ZIP 0xFFFF0007 +#define VNC_ENCODING_TYPE_SOL_MONO_ZIP 0xFFFF0008 +#define VNC_ENCODING_TYPE_ULTRA_ZIP 0xFFFF0009 +#define VNC_ENCODING_TYPE_SERVER_STATE 0xFFFF8000 +#define VNC_ENCODING_TYPE_ENABLE_KEEP_ALIVE 0xFFFF8001 +#define VNC_ENCODING_TYPE_FTP_PROTO_VER 0xFFFF8002 +#define VNC_ENCODING_TYPE_POINTER_CHANGE -257 +#define VNC_ENCODING_TYPE_EXT_KEY_EVENT -258 +#define VNC_ENCODING_TYPE_AUDIO 259 +#define VNC_ENCODING_TYPE_DESKTOP_NAME -307 +#define VNC_ENCODING_TYPE_EXTENDED_DESK_SIZE -308 +#define VNC_ENCODING_TYPE_KEYBOARD_LED_STATE 0XFFFE0000 +#define VNC_ENCODING_TYPE_SUPPORTED_MESSAGES 0XFFFE0001 +#define VNC_ENCODING_TYPE_SUPPORTED_ENCODINGS 0XFFFE0002 +#define VNC_ENCODING_TYPE_SERVER_IDENTITY 0XFFFE0003 +#define VNC_ENCODING_TYPE_MIRRORLINK 0xFFFFFDF5 +#define VNC_ENCODING_TYPE_CONTEXT_INFORMATION 0xFFFFFDF4 +#define VNC_ENCODING_TYPE_SLRLE 0xFFFFFDF3 +#define VNC_ENCODING_TYPE_TRANSFORM 0xFFFFFDF2 +#define VNC_ENCODING_TYPE_HSML 0xFFFFFDF1 +#define VNC_ENCODING_TYPE_H264 0X48323634 + +static const value_string encoding_types_vs[] = { + { VNC_ENCODING_TYPE_DESKTOP_SIZE, "DesktopSize (pseudo)" }, + { VNC_ENCODING_TYPE_LAST_RECT, "LastRect (pseudo)" }, + { VNC_ENCODING_TYPE_POINTER_POS, "Pointer pos (pseudo)" }, + { VNC_ENCODING_TYPE_RICH_CURSOR, "Rich Cursor (pseudo)" }, + { VNC_ENCODING_TYPE_X_CURSOR, "X Cursor (pseudo)" }, + { VNC_ENCODING_TYPE_RAW, "Raw" }, + { VNC_ENCODING_TYPE_COPY_RECT, "CopyRect" }, + { VNC_ENCODING_TYPE_RRE, "RRE" }, + { VNC_ENCODING_TYPE_CORRE, "CoRRE" }, + { VNC_ENCODING_TYPE_HEXTILE, "Hextile" }, + { VNC_ENCODING_TYPE_ZLIB, "Zlib" }, + { VNC_ENCODING_TYPE_TIGHT, "Tight" }, + { VNC_ENCODING_TYPE_ZLIBHEX, "ZlibHex" }, + { VNC_ENCODING_TYPE_ULTRA, "Ultra" }, + { VNC_ENCODING_TYPE_RLE, "ZRLE" }, + { VNC_ENCODING_TYPE_HITACHI_ZYWRLE, "Hitachi ZYWRLE" }, + { VNC_ENCODING_TYPE_JPEG_0, "JPEG quality level 0" }, + { VNC_ENCODING_TYPE_JPEG_1, "JPEG quality level 1" }, + { VNC_ENCODING_TYPE_JPEG_2, "JPEG quality level 2" }, + { VNC_ENCODING_TYPE_JPEG_3, "JPEG quality level 3" }, + { VNC_ENCODING_TYPE_JPEG_4, "JPEG quality level 4" }, + { VNC_ENCODING_TYPE_JPEG_5, "JPEG quality level 5" }, + { VNC_ENCODING_TYPE_JPEG_6, "JPEG quality level 6" }, + { VNC_ENCODING_TYPE_JPEG_7, "JPEG quality level 7" }, + { VNC_ENCODING_TYPE_JPEG_8, "JPEG quality level 8" }, + { VNC_ENCODING_TYPE_JPEG_9, "JPEG quality level 9" }, + { VNC_ENCODING_TYPE_COMPRESSION_0, "Compression level 0" }, + { VNC_ENCODING_TYPE_COMPRESSION_1, "Compression level 1" }, + { VNC_ENCODING_TYPE_COMPRESSION_2, "Compression level 2" }, + { VNC_ENCODING_TYPE_COMPRESSION_3, "Compression level 3" }, + { VNC_ENCODING_TYPE_COMPRESSION_4, "Compression level 4" }, + { VNC_ENCODING_TYPE_COMPRESSION_5, "Compression level 5" }, + { VNC_ENCODING_TYPE_COMPRESSION_6, "Compression level 6" }, + { VNC_ENCODING_TYPE_COMPRESSION_7, "Compression level 7" }, + { VNC_ENCODING_TYPE_COMPRESSION_8, "Compression level 8" }, + { VNC_ENCODING_TYPE_COMPRESSION_9, "Compression level 9" }, + /* FIXME understand for real what the below mean. Taken from Ultra VNC source code */ +/* { VNC_ENCODING_TYPE_CACHE, */ + { VNC_ENCODING_TYPE_CACHE_ENABLE, "Enable Caching"}, +/* { VNC_ENCODING_TYPE_XOR_ZLIB, + { VNC_ENCODING_TYPE_XOR_MONO_ZLIB, + { VNC_ENCODING_TYPE_XOR_MULTI_ZLIB, + { VNC_ENCODING_TYPE_SOLID_COLOR, + { VNC_ENCODING_TYPE_XOR_ENABLE, + { VNC_ENCODING_TYPE_CACHE_ZIP, + { VNC_ENCODING_TYPE_SOL_MONO_ZIP, + { VNC_ENCODING_TYPE_ULTRA_ZIP, +*/ { VNC_ENCODING_TYPE_SERVER_STATE, "Server State" }, + { VNC_ENCODING_TYPE_ENABLE_KEEP_ALIVE, "Enable Keep Alive" }, + { VNC_ENCODING_TYPE_FTP_PROTO_VER, "FTP protocol version" }, + { VNC_ENCODING_TYPE_EXTENDED_DESK_SIZE, "Extended Desktop Size"}, + { VNC_ENCODING_TYPE_DESKTOP_NAME, "Desktop Name" }, + { VNC_ENCODING_TYPE_KEYBOARD_LED_STATE, "Keyboard LED State" }, + { VNC_ENCODING_TYPE_SUPPORTED_MESSAGES, "Supported Messages" }, + { VNC_ENCODING_TYPE_SUPPORTED_ENCODINGS, "Supported Encodings" }, + { VNC_ENCODING_TYPE_SERVER_IDENTITY, "Server Identity" }, + { VNC_ENCODING_TYPE_MIRRORLINK, "MirrorLink" }, + { VNC_ENCODING_TYPE_CONTEXT_INFORMATION, "Context Information" }, + { VNC_ENCODING_TYPE_SLRLE, "SLRLE" }, + { VNC_ENCODING_TYPE_TRANSFORM, "Transform" }, + { VNC_ENCODING_TYPE_HSML, "HSML" }, + { VNC_ENCODING_TYPE_H264, "H264" }, + { 0, NULL } +}; + +/* Rectangle types for Tight encoding. These come in the "control byte" at the + * start of a rectangle's payload. Note that these are with respect to the most + * significant bits 4-7 of the control byte, so you must shift it to the right 4 + * bits before comparing against these values. + */ +#define TIGHT_RECT_FILL 0x08 +#define TIGHT_RECT_JPEG 0x09 +#define TIGHT_RECT_MAX_VALUE 0x09 + +#define TIGHT_RECT_EXPLICIT_FILTER_FLAG 0x04 + +/* Filter types for Basic encoding of Tight rectangles */ +#define TIGHT_RECT_FILTER_COPY 0x00 +#define TIGHT_RECT_FILTER_PALETTE 0x01 +#define TIGHT_RECT_FILTER_GRADIENT 0x02 + +/* Minimum number of bytes to compress for Tight encoding */ +#define TIGHT_MIN_BYTES_TO_COMPRESS 12 + +static const value_string tight_filter_ids_vs[] = { + { TIGHT_RECT_FILTER_COPY, "Copy" }, + { TIGHT_RECT_FILTER_PALETTE, "Palette" }, + { TIGHT_RECT_FILTER_GRADIENT, "Gradient" }, + { 0, NULL } +}; + +/* MirrorLink messages */ +typedef enum { + VNC_ML_EXT_BYE_BYE = 0, + VNC_ML_EXT_SERVER_DISPLAY_CONFIGURATION = 1, + VNC_ML_EXT_CLIENT_DISPLAY_CONFIGURATION = 2, + VNC_ML_EXT_SERVER_EVENT_CONFIGURATION = 3, + VNC_ML_EXT_CLIENT_EVENT_CONFIGURATION = 4, + VNC_ML_EXT_EVENT_MAPPING = 5, + VNC_ML_EXT_EVENT_MAPPING_REQUEST = 6, + VNC_ML_EXT_KEY_EVENT_LISTING = 7, + VNC_ML_EXT_KEY_EVENT_LISTING_REQUEST = 8, + VNC_ML_EXT_VIRTUAL_KEYBOARD = 9, + VNC_ML_EXT_VIRTUAL_KEYBOARD_REQUEST = 10, + VNC_ML_EXT_DEVICE_STATUS = 11, + VNC_ML_EXT_DEVICE_STATUS_REQUEST = 12, + VNC_ML_EXT_CONTENT_ATTESTATION = 13, + VNC_ML_EXT_CONTENT_ATTESTATION_REQUEST = 14, + VNC_ML_EXT_FB_BLOCKING_NOTIFICATION = 16, + VNC_ML_EXT_AUDIO_BLOCKING_NOTIFICATION = 18, + VNC_ML_EXT_TOUCH_EVENT = 20, + VNC_ML_EXT_FB_ALTERNATIVE_TEXT = 21, + VNC_ML_EXT_FB_ALTERNATIVE_TEXT_REQUEST = 22 +} vnc_mirrorlink_ext_types_e; + +static const value_string vnc_mirrorlink_types_vs[] = { + { VNC_ML_EXT_BYE_BYE, "ByeBye" }, + { VNC_ML_EXT_SERVER_DISPLAY_CONFIGURATION, "Server Display Configuration" }, + { VNC_ML_EXT_CLIENT_DISPLAY_CONFIGURATION, "Client Display Configuration" }, + { VNC_ML_EXT_SERVER_EVENT_CONFIGURATION, "Server Event Configuration" }, + { VNC_ML_EXT_CLIENT_EVENT_CONFIGURATION, "Client Event Configuration" }, + { VNC_ML_EXT_EVENT_MAPPING, "Event Mapping" }, + { VNC_ML_EXT_EVENT_MAPPING_REQUEST, "Event Mapping Request" }, + { VNC_ML_EXT_KEY_EVENT_LISTING, "Key Event Listing" }, + { VNC_ML_EXT_KEY_EVENT_LISTING_REQUEST, "Key Event Listing Request" }, + { VNC_ML_EXT_VIRTUAL_KEYBOARD, "Virtual Keyboard Trigger" }, + { VNC_ML_EXT_VIRTUAL_KEYBOARD_REQUEST, "Virtual Keyboard Trigger Request" }, + { VNC_ML_EXT_DEVICE_STATUS, "Device Status" }, + { VNC_ML_EXT_DEVICE_STATUS_REQUEST, "Device Status Request" }, + { VNC_ML_EXT_CONTENT_ATTESTATION, "Content Attestation" }, + { VNC_ML_EXT_CONTENT_ATTESTATION_REQUEST, "Content Attestation Request" }, + { VNC_ML_EXT_FB_BLOCKING_NOTIFICATION, "Framebuffer Blocking Notification" }, + { VNC_ML_EXT_AUDIO_BLOCKING_NOTIFICATION, "Audio Blocking Notification" }, + { VNC_ML_EXT_TOUCH_EVENT, "Touch Event" }, + { VNC_ML_EXT_FB_ALTERNATIVE_TEXT, "Framebuffer Alternative Text" }, + { VNC_ML_EXT_FB_ALTERNATIVE_TEXT_REQUEST, "Framebuffer Alternative Text Request" }, + { 0, NULL } +}; + +/* Slice types for H.264 encoding */ +typedef enum { + VNC_H264_SLICE_TYPE_P = 0, + VNC_H264_SLICE_TYPE_B = 1, + VNC_H264_SLICE_TYPE_I = 2 +} vnc_h264_slice_types_e; + +static const value_string vnc_h264_slice_types_vs[] = { + { VNC_H264_SLICE_TYPE_P, "Predicted" }, + { VNC_H264_SLICE_TYPE_B, "Bi-predicted" }, + { VNC_H264_SLICE_TYPE_I, "Intra coded" }, + { 0, NULL } +}; + + +typedef enum { + VNC_SESSION_STATE_SERVER_VERSION, + VNC_SESSION_STATE_CLIENT_VERSION, + + VNC_SESSION_STATE_SECURITY, + VNC_SESSION_STATE_SECURITY_TYPES, + + VNC_SESSION_STATE_TIGHT_TUNNELING_CAPABILITIES, + VNC_SESSION_STATE_TIGHT_TUNNEL_TYPE_REPLY, + VNC_SESSION_STATE_TIGHT_AUTH_CAPABILITIES, + VNC_SESSION_STATE_TIGHT_AUTH_TYPE_REPLY, + VNC_SESSION_STATE_TIGHT_UNKNOWN_PACKET3, + + VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE, + VNC_SESSION_STATE_VNC_AUTHENTICATION_RESPONSE, + + VNC_SESSION_STATE_ARD_AUTHENTICATION_CHALLENGE, + VNC_SESSION_STATE_ARD_AUTHENTICATION_RESPONSE, + + VNC_SESSION_STATE_SECURITY_RESULT, + + VNC_SESSION_STATE_VENCRYPT_SERVER_VERSION, + VNC_SESSION_STATE_VENCRYPT_CLIENT_VERSION, + VNC_SESSION_STATE_VENCRYPT_AUTH_CAPABILITIES, + VNC_SESSION_STATE_VENCRYPT_AUTH_TYPE_REPLY, + VNC_SESSION_STATE_VENCRYPT_AUTH_ACK, + + VNC_SESSION_STATE_CLIENT_INIT, + VNC_SESSION_STATE_SERVER_INIT, + + VNC_SESSION_STATE_TIGHT_INTERACTION_CAPS, + + VNC_SESSION_STATE_NORMAL_TRAFFIC +} vnc_session_state_e; + +#define VNC_FENCE_BLOCK_BEFORE 0x00000001 +#define VNC_FENCE_BLOCK_AFTER 0x00000002 +#define VNC_FENCE_SYNC_NEXT 0x00000004 +#define VNC_FENCE_REQUEST 0x80000000 + +/* This structure will be tied to each conversation. */ +typedef struct { + gdouble server_proto_ver, client_proto_ver; + vnc_session_state_e vnc_next_state; + guint32 server_port; + /* These are specific to TightVNC */ + gint num_server_message_types; + gint num_client_message_types; + gint num_encoding_types; + guint8 security_type_selected; + gboolean tight_enabled; + /* This is specific to Apple Remote Desktop */ + guint16 ard_key_length; +} vnc_conversation_t; + +/* This structure will be tied to each packet */ +typedef struct { + vnc_session_state_e state; + gint preferred_encoding; + guint8 bytes_per_pixel; + guint8 depth; +} vnc_packet_t; + +void proto_reg_handoff_vnc(void); + +static gboolean vnc_startup_messages(tvbuff_t *tvb, packet_info *pinfo, + gint offset, proto_tree *tree, + vnc_conversation_t *per_conversation_info); +static void vnc_client_to_server(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree); +static void vnc_server_to_client(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree); +static void vnc_client_set_pixel_format(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree); +static void vnc_client_set_encodings(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree); +static void vnc_client_framebuffer_update_request(tvbuff_t *tvb, + packet_info *pinfo, + gint *offset, + proto_tree *tree); +static void vnc_client_key_event(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree); +static void vnc_client_pointer_event(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree); +static void vnc_client_cut_text(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree); + +static guint vnc_server_framebuffer_update(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree); +static guint vnc_raw_encoding(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, const guint16 width, const guint16 height); +static guint vnc_copyrect_encoding(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree, + const guint16 width, const guint16 height); +static guint vnc_rre_encoding(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, const guint16 width, const guint16 height); +static guint vnc_hextile_encoding(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree, + const guint16 width, const guint16 height); +static guint vnc_zrle_encoding(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, const guint16 width, const guint16 height); +static guint vnc_tight_encoding(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, const guint16 width, const guint16 height); +static guint vnc_rich_cursor_encoding(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree, const guint16 width, + const guint16 height); +static guint vnc_x_cursor_encoding(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree, const guint16 width, + const guint16 height); +static guint vnc_server_set_colormap_entries(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree); +static void vnc_server_ring_bell(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree); +static guint vnc_server_cut_text(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree); +static void vnc_set_bytes_per_pixel(packet_info *pinfo, const guint8 bytes_per_pixel); +static void vnc_set_depth(packet_info *pinfo, const guint8 depth); +static guint8 vnc_get_bytes_per_pixel(packet_info *pinfo); +static guint8 vnc_get_depth(packet_info *pinfo); +static guint32 vnc_extended_desktop_size(tvbuff_t *tvb, gint *offset, proto_tree *tree); + +static guint vnc_supported_messages(tvbuff_t *tvb, gint *offset, + proto_tree *tree, const guint16 width); +static guint vnc_supported_encodings(tvbuff_t *tvb, gint *offset, + proto_tree *tree, const guint16 width, + const guint16 height); +static guint vnc_server_identity(tvbuff_t *tvb, gint *offset, + proto_tree *tree, const guint16 width); + +static guint vnc_fence(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree); +static guint vnc_mirrorlink(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree); +static guint vnc_context_information(tvbuff_t *tvb, gint *offset, + proto_tree *tree); +static guint vnc_slrle_encoding(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, const guint16 height); + +static guint vnc_h264_encoding(tvbuff_t *tvb, gint *offset, proto_tree *tree); + +#define VNC_BYTES_NEEDED(a) \ + if((a) > (guint)tvb_reported_length_remaining(tvb, *offset)) \ + return (a); + +/* Initialize the protocol and registered fields */ +static int proto_vnc = -1; /* Protocol subtree */ +static int hf_vnc_padding = -1; +static int hf_vnc_server_proto_ver = -1; +static int hf_vnc_client_proto_ver = -1; +static int hf_vnc_num_security_types = -1; +static int hf_vnc_security_type = -1; +static int hf_vnc_server_security_type = -1; +static int hf_vnc_client_security_type = -1; +static int hf_vnc_auth_challenge = -1; +static int hf_vnc_auth_response = -1; +static int hf_vnc_auth_result = -1; +static int hf_vnc_auth_error = -1; +static int hf_vnc_auth_error_length = -1; + +static int hf_vnc_ard_auth_generator = -1; +static int hf_vnc_ard_auth_key_len = -1; +static int hf_vnc_ard_auth_modulus = -1; +static int hf_vnc_ard_auth_server_key = -1; +static int hf_vnc_ard_auth_credentials = -1; +static int hf_vnc_ard_auth_client_key = -1; + +static int hf_vnc_share_desktop_flag = -1; +static int hf_vnc_width = -1; +static int hf_vnc_height = -1; +static int hf_vnc_server_bits_per_pixel = -1; +static int hf_vnc_server_depth = -1; +static int hf_vnc_server_big_endian_flag = -1; +static int hf_vnc_server_true_color_flag = -1; +static int hf_vnc_server_red_max = -1; +static int hf_vnc_server_green_max = -1; +static int hf_vnc_server_blue_max = -1; +static int hf_vnc_server_red_shift = -1; +static int hf_vnc_server_green_shift = -1; +static int hf_vnc_server_blue_shift = -1; +static int hf_vnc_desktop_name = -1; +static int hf_vnc_desktop_name_len = -1; +static int hf_vnc_desktop_screen_num = -1; +static int hf_vnc_desktop_screen_id = -1; +static int hf_vnc_desktop_screen_x = -1; +static int hf_vnc_desktop_screen_y = -1; +static int hf_vnc_desktop_screen_width = -1; +static int hf_vnc_desktop_screen_height = -1; +static int hf_vnc_desktop_screen_flags = -1; +static int hf_vnc_num_server_message_types = -1; +static int hf_vnc_num_client_message_types = -1; +static int hf_vnc_num_encoding_types = -1; + +/********** Client Message Types **********/ + +static int hf_vnc_client_message_type = -1; /* A subtree under VNC */ +static int hf_vnc_client_bits_per_pixel = -1; +static int hf_vnc_client_depth = -1; +static int hf_vnc_client_big_endian_flag = -1; +static int hf_vnc_client_true_color_flag = -1; +static int hf_vnc_client_red_max = -1; +static int hf_vnc_client_green_max = -1; +static int hf_vnc_client_blue_max = -1; +static int hf_vnc_client_red_shift = -1; +static int hf_vnc_client_green_shift = -1; +static int hf_vnc_client_blue_shift = -1; + +/* Client Key Event */ +static int hf_vnc_key_down = -1; +static int hf_vnc_key = -1; + +/* Client Pointer Event */ +static int hf_vnc_button_1_pos = -1; +static int hf_vnc_button_2_pos = -1; +static int hf_vnc_button_3_pos = -1; +static int hf_vnc_button_4_pos = -1; +static int hf_vnc_button_5_pos = -1; +static int hf_vnc_button_6_pos = -1; +static int hf_vnc_button_7_pos = -1; +static int hf_vnc_button_8_pos = -1; +static int hf_vnc_pointer_x_pos = -1; +static int hf_vnc_pointer_y_pos = -1; + +/* Client Framebuffer Update Request */ +static int hf_vnc_update_req_incremental = -1; +static int hf_vnc_update_req_x_pos = -1; +static int hf_vnc_update_req_y_pos = -1; +static int hf_vnc_update_req_width = -1; +static int hf_vnc_update_req_height = -1; + +/* Client Set Encodings */ +static int hf_vnc_encoding_num = -1; +static int hf_vnc_client_set_encodings_encoding_type = -1; + +/* Client Cut Text */ +static int hf_vnc_client_cut_text_len = -1; +static int hf_vnc_client_cut_text = -1; + +/********** Server Message Types **********/ + +static int hf_vnc_server_message_type = -1; /* Subtree */ + +/* Tunneling capabilities (TightVNC extension) */ +static int hf_vnc_tight_num_tunnel_types = -1; +static int hf_vnc_tight_tunnel_type_code = -1; +static int hf_vnc_tight_tunnel_type_vendor = -1; +static int hf_vnc_tight_tunnel_type_signature = -1; + +/* Authentication capabilities (TightVNC extension) */ +static int hf_vnc_tight_num_auth_types = -1; +static int hf_vnc_tight_auth_code = -1; +/* TightVNC capabilities */ +static int hf_vnc_tight_server_message_type = -1; +static int hf_vnc_tight_server_vendor = -1; +static int hf_vnc_tight_signature = -1; +static int hf_vnc_tight_server_name = -1; + +static int hf_vnc_tight_client_message_type = -1; +static int hf_vnc_tight_client_vendor = -1; +static int hf_vnc_tight_client_name = -1; + +static int hf_vnc_tight_encoding_type = -1; +static int hf_vnc_tight_encoding_vendor = -1; +static int hf_vnc_tight_encoding_name = -1; + +/* VeNCrypt capabilities */ +static int hf_vnc_vencrypt_server_major_ver = -1; +static int hf_vnc_vencrypt_server_minor_ver = -1; +static int hf_vnc_vencrypt_client_major_ver = -1; +static int hf_vnc_vencrypt_client_minor_ver = -1; +static int hf_vnc_vencrypt_version_ack = -1; +static int hf_vnc_vencrypt_num_auth_types = -1; +static int hf_vnc_vencrypt_auth_type = -1; +static int hf_vnc_vencrypt_auth_type_ack = -1; + +/* Tight compression parameters */ +static int hf_vnc_tight_reset_stream0 = -1; +static int hf_vnc_tight_reset_stream1 = -1; +static int hf_vnc_tight_reset_stream2 = -1; +static int hf_vnc_tight_reset_stream3 = -1; + +static int hf_vnc_tight_rect_type = -1; + +static int hf_vnc_tight_image_len = -1; +static int hf_vnc_tight_image_data = -1; + +static int hf_vnc_tight_fill_color = -1; + +static int hf_vnc_tight_filter_flag = -1; +static int hf_vnc_tight_filter_id = -1; + +static int hf_vnc_tight_palette_num_colors = -1; +static int hf_vnc_tight_palette_data = -1; + +/* Server Framebuffer Update */ +static int hf_vnc_rectangle_num = -1; +static int hf_vnc_fb_update_x_pos = -1; +static int hf_vnc_fb_update_y_pos = -1; +static int hf_vnc_fb_update_width = -1; +static int hf_vnc_fb_update_height = -1; +static int hf_vnc_fb_update_encoding_type = -1; + +/* Raw Encoding */ +static int hf_vnc_raw_pixel_data = -1; + +/* CopyRect Encoding */ +static int hf_vnc_copyrect_src_x_pos = -1; +static int hf_vnc_copyrect_src_y_pos = -1; + +/* RRE Encoding */ +static int hf_vnc_rre_num_subrects = -1; +static int hf_vnc_rre_bg_pixel = -1; + +static int hf_vnc_rre_subrect_pixel = -1; +static int hf_vnc_rre_subrect_x_pos = -1; +static int hf_vnc_rre_subrect_y_pos = -1; +static int hf_vnc_rre_subrect_width = -1; +static int hf_vnc_rre_subrect_height = -1; + +/* Hextile Encoding */ +static int hf_vnc_hextile_subencoding_mask = -1; +static int hf_vnc_hextile_raw = -1; +static int hf_vnc_hextile_raw_value = -1; +static int hf_vnc_hextile_bg = -1; +static int hf_vnc_hextile_bg_value = -1; +static int hf_vnc_hextile_fg = -1; +static int hf_vnc_hextile_fg_value = -1; +static int hf_vnc_hextile_anysubrects = -1; +static int hf_vnc_hextile_num_subrects = -1; +static int hf_vnc_hextile_subrectscolored = -1; +static int hf_vnc_hextile_subrect_pixel_value = -1; +static int hf_vnc_hextile_subrect_x_pos = -1; +static int hf_vnc_hextile_subrect_y_pos = -1; +static int hf_vnc_hextile_subrect_width = -1; +static int hf_vnc_hextile_subrect_height = -1; + +/* ZRLE Encoding */ +static int hf_vnc_zrle_len = -1; +static int hf_vnc_zrle_subencoding = -1; +static int hf_vnc_zrle_rle = -1; +static int hf_vnc_zrle_palette_size = -1; +static int hf_vnc_zrle_data = -1; +static int hf_vnc_zrle_raw = -1; +static int hf_vnc_zrle_palette = -1; + +/* Cursor Encoding */ +static int hf_vnc_cursor_x_fore_back = -1; +static int hf_vnc_cursor_encoding_pixels = -1; +static int hf_vnc_cursor_encoding_bitmask = -1; + +/* Server Set Colormap Entries */ +static int hf_vnc_color_groups = -1; +static int hf_vnc_colormap_first_color = -1; +static int hf_vnc_colormap_num_colors = -1; +static int hf_vnc_colormap_red = -1; +static int hf_vnc_colormap_green = -1; +static int hf_vnc_colormap_blue = -1; + +/* Server Cut Text */ +static int hf_vnc_server_cut_text_len = -1; +static int hf_vnc_server_cut_text = -1; + +/* LibVNCServer additions */ +static int hf_vnc_supported_messages_client2server = -1; +static int hf_vnc_supported_messages_server2client = -1; +static int hf_vnc_num_supported_encodings = -1; +static int hf_vnc_supported_encodings = -1; +static int hf_vnc_server_identity = -1; + +/* MirrorLink */ +static int hf_vnc_mirrorlink_type = -1; +static int hf_vnc_mirrorlink_length = -1; +static int hf_vnc_mirrorlink_version_major = -1; +static int hf_vnc_mirrorlink_version_minor = -1; +static int hf_vnc_mirrorlink_framebuffer_configuration = -1; +static int hf_vnc_mirrorlink_pixel_width = -1; +static int hf_vnc_mirrorlink_pixel_height = -1; +static int hf_vnc_mirrorlink_pixel_format = -1; +static int hf_vnc_mirrorlink_display_width = -1; +static int hf_vnc_mirrorlink_display_height = -1; +static int hf_vnc_mirrorlink_display_distance = -1; +static int hf_vnc_mirrorlink_keyboard_language = -1; +static int hf_vnc_mirrorlink_keyboard_country = -1; +static int hf_vnc_mirrorlink_ui_language = -1; +static int hf_vnc_mirrorlink_ui_country = -1; +static int hf_vnc_mirrorlink_knob_keys = -1; +static int hf_vnc_mirrorlink_device_keys = -1; +static int hf_vnc_mirrorlink_multimedia_keys = -1; +static int hf_vnc_mirrorlink_key_related = -1; +static int hf_vnc_mirrorlink_pointer_related = -1; +static int hf_vnc_mirrorlink_key_symbol_value_client = -1; +static int hf_vnc_mirrorlink_key_symbol_value_server = -1; +static int hf_vnc_mirrorlink_key_configuration = -1; +static int hf_vnc_mirrorlink_key_num_events = -1; +static int hf_vnc_mirrorlink_key_event_counter = -1; +static int hf_vnc_mirrorlink_key_symbol_value = -1; +static int hf_vnc_mirrorlink_key_request_configuration = -1; +static int hf_vnc_mirrorlink_keyboard_configuration = -1; +static int hf_vnc_mirrorlink_cursor_x = -1; +static int hf_vnc_mirrorlink_cursor_y = -1; +static int hf_vnc_mirrorlink_text_x = -1; +static int hf_vnc_mirrorlink_text_y = -1; +static int hf_vnc_mirrorlink_text_width = -1; +static int hf_vnc_mirrorlink_text_height = -1; +static int hf_vnc_mirrorlink_keyboard_request_configuration = -1; +static int hf_vnc_mirrorlink_device_status = -1; +static int hf_vnc_mirrorlink_app_id = -1; +static int hf_vnc_mirrorlink_fb_block_x = -1; +static int hf_vnc_mirrorlink_fb_block_y = -1; +static int hf_vnc_mirrorlink_fb_block_width = -1; +static int hf_vnc_mirrorlink_fb_block_height = -1; +static int hf_vnc_mirrorlink_fb_block_reason = -1; +static int hf_vnc_mirrorlink_audio_block_reason = -1; +static int hf_vnc_mirrorlink_touch_num_events = -1; +static int hf_vnc_mirrorlink_touch_x = -1; +static int hf_vnc_mirrorlink_touch_y = -1; +static int hf_vnc_mirrorlink_touch_id = -1; +static int hf_vnc_mirrorlink_touch_pressure = -1; +static int hf_vnc_mirrorlink_text = -1; +static int hf_vnc_mirrorlink_text_length = -1; +static int hf_vnc_mirrorlink_text_max_length = -1; +static int hf_vnc_mirrorlink_unknown = -1; + +/* Fence */ +static int hf_vnc_fence_flags = -1; +static int hf_vnc_fence_request = -1; +static int hf_vnc_fence_sync_next = -1; +static int hf_vnc_fence_block_after = -1; +static int hf_vnc_fence_block_before = -1; +static int hf_vnc_fence_payload_length = -1; +static int hf_vnc_fence_payload = -1; + +static int * const vnc_fence_flags[] = { + &hf_vnc_fence_request, + &hf_vnc_fence_sync_next, + &hf_vnc_fence_block_after, + &hf_vnc_fence_block_before, + NULL +}; + +/* Context Information */ +static int hf_vnc_context_information_app_id = -1; +static int hf_vnc_context_information_app_category = -1; +static int hf_vnc_context_information_app_trust_level = -1; +static int hf_vnc_context_information_content_category = -1; +static int hf_vnc_context_information_content_rules = -1; +static int hf_vnc_context_information_content_trust_level = -1; + +/* Scan Line based Run-Length Encoding */ +static int hf_vnc_slrle_run_num = -1; +static int hf_vnc_slrle_run_data = -1; + +/* H.264 Encoding */ +static int hf_vnc_h264_slice_type = -1; +static int hf_vnc_h264_nbytes = -1; +static int hf_vnc_h264_width = -1; +static int hf_vnc_h264_height = -1; +static int hf_vnc_h264_data = -1; + +/********** End of Server Message Types **********/ + +static gboolean vnc_preference_desegment = TRUE; + +/* Initialize the subtree pointers */ +static gint ett_vnc = -1; +static gint ett_vnc_client_message_type = -1; +static gint ett_vnc_server_message_type = -1; +static gint ett_vnc_rect = -1; +static gint ett_vnc_encoding_type = -1; +static gint ett_vnc_rre_subrect = -1; +static gint ett_vnc_hextile_subencoding_mask = -1; +static gint ett_vnc_hextile_num_subrects = -1; +static gint ett_vnc_hextile_subrect = -1; +static gint ett_vnc_hextile_tile = -1; +static gint ett_vnc_zrle_subencoding = -1; +static gint ett_vnc_colormap_num_groups = -1; +static gint ett_vnc_colormap_color_group = -1; +static gint ett_vnc_desktop_screen = -1; +static gint ett_vnc_key_events = -1; +static gint ett_vnc_touch_events = -1; +static gint ett_vnc_slrle_subline = -1; +static gint ett_vnc_fence_flags = -1; + +static expert_field ei_vnc_possible_gtk_vnc_bug = EI_INIT; +static expert_field ei_vnc_auth_code_mismatch = EI_INIT; +static expert_field ei_vnc_unknown_tight_vnc_auth = EI_INIT; +static expert_field ei_vnc_too_many_rectangles = EI_INIT; +static expert_field ei_vnc_too_many_sub_rectangles = EI_INIT; +static expert_field ei_vnc_invalid_encoding = EI_INIT; +static expert_field ei_vnc_too_many_colors = EI_INIT; +static expert_field ei_vnc_too_many_cut_text = EI_INIT; +static expert_field ei_vnc_zrle_failed = EI_INIT; +static expert_field ei_vnc_unknown_tight = EI_INIT; +static expert_field ei_vnc_reassemble = EI_INIT; + +/* Global so they keep their value between packets */ +guint8 vnc_bytes_per_pixel; +guint8 vnc_depth; + +#define VNC_PORT_RANGE "5500-5501,5900-5901" /* Not IANA registered */ + +static range_t *vnc_tcp_range = NULL; +static dissector_handle_t vnc_handle; +static dissector_handle_t tls_handle; + +/* Code to dissect the packets */ +static int +dissect_vnc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) +{ + gboolean ret; + gint offset = 0; + + /* Set up structures needed to add the protocol subtree and manage it */ + proto_item *ti; + proto_tree *vnc_tree; + + conversation_t *conversation; + vnc_conversation_t *per_conversation_info; + + conversation = find_or_create_conversation(pinfo); + + /* Retrieve information from conversation, or add it if it isn't + * there yet */ + per_conversation_info = (vnc_conversation_t *)conversation_get_proto_data(conversation, proto_vnc); + if(!per_conversation_info) { + per_conversation_info = wmem_new(wmem_file_scope(), vnc_conversation_t); + + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SERVER_VERSION; + per_conversation_info->security_type_selected = VNC_SECURITY_TYPE_INVALID; + per_conversation_info->tight_enabled = FALSE; + + conversation_add_proto_data(conversation, proto_vnc, per_conversation_info); + } + + + /* Make entries in Protocol column and Info column on summary display */ + col_set_str(pinfo->cinfo, COL_PROTOCOL, "VNC"); + + /* First, clear the info column */ + col_clear(pinfo->cinfo, COL_INFO); + + /* create display subtree for the protocol */ + ti = proto_tree_add_item(tree, proto_vnc, tvb, 0, -1, ENC_NA); + vnc_tree = proto_item_add_subtree(ti, ett_vnc); + + /* Dissect any remaining session startup messages */ + ret = vnc_startup_messages(tvb, pinfo, offset, vnc_tree, + per_conversation_info); + + vnc_set_bytes_per_pixel(pinfo, vnc_bytes_per_pixel); + vnc_set_depth(pinfo, vnc_depth); + + if (ret) { + return tvb_captured_length(tvb); /* We're in a "startup" state; Cannot yet do "normal" processing */ + } + + if (per_conversation_info->security_type_selected == VNC_SECURITY_TYPE_VENCRYPT) { + call_dissector_with_data(tls_handle, tvb, pinfo, vnc_tree, GUINT_TO_POINTER(offset)); + return tvb_captured_length(tvb); + } + + if(value_is_in_range(vnc_tcp_range, pinfo->destport) || per_conversation_info->server_port == pinfo->destport) { + vnc_client_to_server(tvb, pinfo, &offset, vnc_tree); + } + else { + vnc_server_to_client(tvb, pinfo, &offset, vnc_tree); + } + return tvb_captured_length(tvb); +} + +/* Returns the new offset after processing the 4-byte vendor string */ +static gint +process_vendor(proto_tree *tree, gint hfindex, tvbuff_t *tvb, gint offset) +{ + const guint8 *vendor; + proto_item *ti; + + if (tree) { + ti = proto_tree_add_item_ret_string(tree, hfindex, tvb, offset, 4, ENC_ASCII|ENC_NA, wmem_packet_scope(), &vendor); + + if(g_ascii_strcasecmp(vendor, "STDV") == 0) + proto_item_append_text(ti, " (Standard VNC vendor)"); + else if(g_ascii_strcasecmp(vendor, "TRDV") == 0) + proto_item_append_text(ti, " (Tridia VNC vendor)"); + else if(g_ascii_strcasecmp(vendor, "TGHT") == 0) + proto_item_append_text(ti, " (Tight VNC vendor)"); + } + + offset += 4; + return offset; +} + +/* Returns the new offset after processing the specified number of capabilities */ +static gint +process_tight_capabilities(proto_tree *tree, + gint type_index, gint vendor_index, gint name_index, + tvbuff_t *tvb, gint offset, const gint num_capabilities) +{ + gint i; + /* See vnc_unixsrc/include/rfbproto.h:rfbCapabilityInfo */ + + for (i = 0; i < num_capabilities; i++) { + + proto_tree_add_item(tree, type_index, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + offset = process_vendor(tree, vendor_index, tvb, offset); + + proto_tree_add_item(tree, name_index, tvb, offset, 8, ENC_ASCII|ENC_NA); + offset += 8; + } + + return offset; +} + +/* Returns true if this looks like a client or server version packet: 12 bytes, in the format "RFB xxx.yyy\n" . +* Will check for the 12 bytes exact length, the 'RFB ' string and that it ends with a '\n'. +* The exact 'xxx.yyy' is checked later, by trying to convert it to a double using g_ascii_strtod. +* pinfo and tree are NULL when using this function to check the heuristics for dissection. If we're +* checking the heuristics, we don't need to add expert_info, we just reject that packet as not +* being a VNC packet. +*/ +static gboolean +vnc_is_client_or_server_version_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + if(tvb_captured_length(tvb) != 12) { + return FALSE; + } + + if(tvb_strncaseeql(tvb, 0, "RFB ", 4) != 0) { + return FALSE; + } + + /* 0x2e = '.' 0xa = '\n' */ + if (tvb_get_guint8(tvb, 7) != 0x2e) { + return FALSE; + } + + if (tvb_get_guint8(tvb,11) != 0xa) { + if (tvb_get_guint8(tvb,11) == 0) { + /* Per bug 5469, It appears that any VNC clients using gtk-vnc before [1] was + * fixed will exhibit the described protocol violation that prevents wireshark + * from dissecting the session. + * + * [1] http://git.gnome.org/browse/gtk-vnc/commit/?id=bc9e2b19167686dd381a0508af1a5113675d08a2 + */ + if ((pinfo != NULL) && (tree != NULL)) { + proto_tree_add_expert(tree, pinfo, &ei_vnc_possible_gtk_vnc_bug, tvb, -1, 0); + } + + return TRUE; + } + + return FALSE; + } + + return TRUE; +} + +static gboolean test_vnc_protocol(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree, void *data _U_) +{ + conversation_t *conversation; + + if (vnc_is_client_or_server_version_message(tvb, NULL, NULL)) { + conversation = conversation_new(pinfo->num, &pinfo->src, + &pinfo->dst, conversation_pt_to_conversation_type(pinfo->ptype), + pinfo->srcport, + pinfo->destport, 0); + conversation_set_dissector(conversation, vnc_handle); + dissect_vnc(tvb, pinfo, tree, data); + return TRUE; + } + return FALSE; +} + +/* Returns true if additional session startup messages follow */ +static gboolean +vnc_startup_messages(tvbuff_t *tvb, packet_info *pinfo, gint offset, + proto_tree *tree, vnc_conversation_t + *per_conversation_info) +{ + guint8 num_security_types; + guint32 desktop_name_len, auth_result, text_len, auth_code; + vnc_packet_t *per_packet_info; + gint num_tunnel_types; + gint num_auth_types; + proto_item* auth_item; + + per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); + + if(!per_packet_info) { + per_packet_info = wmem_new(wmem_file_scope(), vnc_packet_t); + + per_packet_info->state = per_conversation_info->vnc_next_state; + per_packet_info->preferred_encoding = -1; + + p_add_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0, per_packet_info); + } + + /* Packet dissection follows */ + switch(per_packet_info->state) { + + case VNC_SESSION_STATE_SERVER_VERSION : + if (!vnc_is_client_or_server_version_message(tvb, pinfo, tree)) + return TRUE; /* we still hope to get a SERVER_VERSION message some day. Do not proceed yet */ + + proto_tree_add_item(tree, hf_vnc_server_proto_ver, tvb, 4, + 7, ENC_ASCII); + per_conversation_info->server_proto_ver = + g_ascii_strtod((char *)tvb_get_string_enc(wmem_packet_scope(), tvb, 4, 7, ENC_ASCII), NULL); + per_conversation_info->server_port = pinfo->srcport; + + col_add_fstr(pinfo->cinfo, COL_INFO, + "Server protocol version: %s", + tvb_format_text(pinfo->pool, tvb, 4, 7)); + + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_VERSION; + break; + + case VNC_SESSION_STATE_CLIENT_VERSION : + if (!vnc_is_client_or_server_version_message(tvb, pinfo, tree)) + return TRUE; /* we still hope to get a CLIENT_VERSION message some day. Do not proceed yet */ + + proto_tree_add_item(tree, hf_vnc_client_proto_ver, tvb, + 4, 7, ENC_ASCII); + per_conversation_info->client_proto_ver = + g_ascii_strtod((char *)tvb_get_string_enc(wmem_packet_scope(), tvb, 4, 7, ENC_ASCII), NULL); + + col_add_fstr(pinfo->cinfo, COL_INFO, + "Client protocol version: %s", + tvb_format_text(pinfo->pool, tvb, 4, 7)); + + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SECURITY; + break; + + case VNC_SESSION_STATE_SECURITY : + col_set_str(pinfo->cinfo, COL_INFO, "Security types supported"); + + /* We're checking against the client protocol version because + * the client is the final decider on which version to use + * after the server offers the highest version it supports. */ + + if(per_conversation_info->client_proto_ver >= 3.007) { + num_security_types = tvb_get_guint8(tvb, offset); + if (tree) { + proto_tree_add_item(tree, + hf_vnc_num_security_types, + tvb, offset, 1, ENC_BIG_ENDIAN); + + for(offset = 1; offset <= num_security_types; offset++){ + proto_tree_add_item(tree, + hf_vnc_security_type, tvb, + offset, 1, ENC_BIG_ENDIAN); + } + } + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SECURITY_TYPES; + } else { + /* Version < 3.007: The server decides the + * authentication type for us to use */ + proto_tree_add_item(tree, hf_vnc_server_security_type, + tvb, offset, 4, ENC_BIG_ENDIAN); + /* The cast below is possible since in older versions of the protocol the only possible values are 0,1,2 */ + per_conversation_info->security_type_selected = (guint8)tvb_get_ntohl(tvb, offset); + switch(per_conversation_info->security_type_selected) { + + case VNC_SECURITY_TYPE_INVALID: + /* TODO: In this case (INVALID) the connection has failed */ + /* and there should be an error string describing the error */ + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SECURITY_TYPES; + break; + + case VNC_SECURITY_TYPE_NONE: + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_INIT; + break; + + case VNC_SECURITY_TYPE_VNC: + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE; + break; + + case VNC_SECURITY_TYPE_ARD: + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_ARD_AUTHENTICATION_CHALLENGE; + break; + + default: + /* Security type not supported by this dissector */ + break; + } + } + + break; + + case VNC_SESSION_STATE_SECURITY_TYPES : + proto_tree_add_item(tree, hf_vnc_client_security_type, tvb, offset, 1, ENC_BIG_ENDIAN); + per_conversation_info->security_type_selected = + tvb_get_guint8(tvb, offset); + col_add_fstr(pinfo->cinfo, COL_INFO, "Security type %s (%d) selected by client", + val_to_str_const(per_conversation_info->security_type_selected, vnc_security_types_vs, "Unknown"), + per_conversation_info->security_type_selected); + + switch(per_conversation_info->security_type_selected) { + + case VNC_SECURITY_TYPE_NONE : + if(per_conversation_info->client_proto_ver >= 3.008) + per_conversation_info->vnc_next_state = + VNC_SESSION_STATE_SECURITY_RESULT; + else + per_conversation_info->vnc_next_state = + VNC_SESSION_STATE_CLIENT_INIT; + + break; + + case VNC_SECURITY_TYPE_VNC : + per_conversation_info->vnc_next_state = + VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE; + break; + + case VNC_SECURITY_TYPE_TIGHT : + per_conversation_info->vnc_next_state = + VNC_SESSION_STATE_TIGHT_TUNNELING_CAPABILITIES; + per_conversation_info->tight_enabled = TRUE; + break; + + case VNC_SECURITY_TYPE_ARD: + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_ARD_AUTHENTICATION_CHALLENGE; + break; + + case VNC_SECURITY_TYPE_VENCRYPT: + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VENCRYPT_SERVER_VERSION; + break; + default : + /* Security type not supported by this dissector */ + break; + } + + break; + + case VNC_SESSION_STATE_TIGHT_TUNNELING_CAPABILITIES : + { + gint i; + + col_set_str(pinfo->cinfo, COL_INFO, "TightVNC tunneling capabilities supported"); + + proto_tree_add_item(tree, hf_vnc_tight_num_tunnel_types, tvb, offset, 4, ENC_BIG_ENDIAN); + num_tunnel_types = tvb_get_ntohl(tvb, offset); + + offset += 4; + + for(i = 0; i < num_tunnel_types; i++) { + /* TightVNC and Xvnc don't support any tunnel capabilities yet, but each capability + * is 16 bytes, so skip them. + */ + + proto_tree_add_item(tree, hf_vnc_tight_tunnel_type_code, tvb, offset, 4, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_vnc_tight_tunnel_type_vendor, tvb, offset + 4, 4, ENC_ASCII); + proto_tree_add_item(tree, hf_vnc_tight_tunnel_type_signature, tvb, offset + 8, 8, ENC_ASCII); + offset += 16; + } + + if (num_tunnel_types == 0) + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_AUTH_CAPABILITIES; + else + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_TUNNEL_TYPE_REPLY; + break; + } + case VNC_SESSION_STATE_TIGHT_TUNNEL_TYPE_REPLY: + /* Neither TightVNC nor Xvnc implement this; they just have a placeholder that emits an error + * message and closes the connection (xserver/hw/vnc/auth.c:rfbProcessClientTunnelingType). + * We should actually never get here... + */ + break; + + case VNC_SESSION_STATE_TIGHT_AUTH_CAPABILITIES: + { + const guint8 *vendor, *signature; + + col_set_str(pinfo->cinfo, COL_INFO, "TightVNC authentication capabilities supported"); + + proto_tree_add_item(tree, hf_vnc_tight_num_auth_types, tvb, offset, 4, ENC_BIG_ENDIAN); + num_auth_types = tvb_get_ntohl(tvb, offset); + offset += 4; + + auth_code = tvb_get_ntohl(tvb, offset); + auth_item = proto_tree_add_item(tree, hf_vnc_tight_auth_code, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + vendor = tvb_get_string_enc(wmem_packet_scope(), tvb, offset, 4, ENC_ASCII); + process_vendor(tree, hf_vnc_tight_server_vendor, tvb, offset); + offset += 4; + proto_tree_add_item_ret_string(tree, hf_vnc_tight_signature, tvb, offset, 8, ENC_ASCII|ENC_NA, wmem_packet_scope(), &signature); + + switch(auth_code) { + case VNC_SECURITY_TYPE_NONE: + if ((g_ascii_strcasecmp(vendor, "STDV") != 0) || (g_ascii_strcasecmp(signature, "NOAUTH__") != 0)) { + expert_add_info(pinfo, auth_item, &ei_vnc_auth_code_mismatch); + } + break; + case VNC_SECURITY_TYPE_VNC: + if ((g_ascii_strcasecmp(vendor, "STDV") != 0) || (g_ascii_strcasecmp(signature, "VNCAUTH_") != 0)) { + expert_add_info(pinfo, auth_item, &ei_vnc_auth_code_mismatch); + } + break; + case VNC_SECURITY_TYPE_VENCRYPT: + if ((g_ascii_strcasecmp(vendor, "VENC") != 0) || (g_ascii_strcasecmp(signature, "VENCRYPT") != 0)) { + expert_add_info(pinfo, auth_item, &ei_vnc_auth_code_mismatch); + } + break; + case VNC_SECURITY_TYPE_GTK_VNC_SASL: + if ((g_ascii_strcasecmp(vendor, "GTKV") != 0) || (g_ascii_strcasecmp(signature, "SASL____") != 0)) { + expert_add_info(pinfo, auth_item, &ei_vnc_auth_code_mismatch); + } + break; + case VNC_TIGHT_AUTH_TGHT_ULGNAUTH: + if ((g_ascii_strcasecmp(vendor, "TGHT") != 0) || (g_ascii_strcasecmp(signature, "ULGNAUTH") != 0)) { + expert_add_info(pinfo, auth_item, &ei_vnc_auth_code_mismatch); + } + break; + case VNC_TIGHT_AUTH_TGHT_XTRNAUTH: + if ((g_ascii_strcasecmp(vendor, "TGHT") != 0) || (g_ascii_strcasecmp(signature, "XTRNAUTH") != 0)) { + expert_add_info(pinfo, auth_item, &ei_vnc_auth_code_mismatch); + } + break; + default: + expert_add_info(pinfo, auth_item, &ei_vnc_unknown_tight_vnc_auth); + break; + } + + if (num_auth_types == 0) + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_INIT; + else + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_AUTH_TYPE_REPLY; + break; + } + case VNC_SESSION_STATE_TIGHT_AUTH_TYPE_REPLY: + col_set_str(pinfo->cinfo, COL_INFO, "TightVNC authentication type selected by client"); + auth_code = tvb_get_ntohl(tvb, offset); + auth_item = proto_tree_add_item(tree, hf_vnc_tight_auth_code, tvb, offset, 4, ENC_BIG_ENDIAN); + + switch(auth_code) { + case VNC_SECURITY_TYPE_NONE: + per_conversation_info->security_type_selected = VNC_SECURITY_TYPE_NONE; + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_INIT; + break; + case VNC_SECURITY_TYPE_VNC: + per_conversation_info->security_type_selected = VNC_SECURITY_TYPE_VNC; + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE; + break; + case VNC_SECURITY_TYPE_GTK_VNC_SASL: + per_conversation_info->security_type_selected = VNC_SECURITY_TYPE_GTK_VNC_SASL; + /* TODO: dissection not implemented yet */ + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_UNKNOWN_PACKET3; + break; + case VNC_TIGHT_AUTH_TGHT_ULGNAUTH: + per_conversation_info->security_type_selected = VNC_TIGHT_AUTH_TGHT_ULGNAUTH; + /* TODO: dissection not implemented yet */ + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_UNKNOWN_PACKET3; + break; + case VNC_TIGHT_AUTH_TGHT_XTRNAUTH: + per_conversation_info->security_type_selected = VNC_TIGHT_AUTH_TGHT_XTRNAUTH; + /* TODO: dissection not implemented yet */ + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_UNKNOWN_PACKET3; + break; + default: + expert_add_info(pinfo, auth_item, &ei_vnc_unknown_tight_vnc_auth); + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_TIGHT_UNKNOWN_PACKET3; + break; + } + + break; + + case VNC_SESSION_STATE_TIGHT_UNKNOWN_PACKET3 : + col_set_str(pinfo->cinfo, COL_INFO, "Unknown packet (TightVNC)"); + + proto_tree_add_expert(tree, pinfo, &ei_vnc_unknown_tight, tvb, offset, -1); + + per_conversation_info->vnc_next_state = + VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE; + + break; + + case VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE : + col_set_str(pinfo->cinfo, COL_INFO, "Authentication challenge from server"); + + proto_tree_add_item(tree, hf_vnc_auth_challenge, tvb, + offset, 16, ENC_NA); + + per_conversation_info->vnc_next_state = + VNC_SESSION_STATE_VNC_AUTHENTICATION_RESPONSE; + break; + + case VNC_SESSION_STATE_VNC_AUTHENTICATION_RESPONSE : + col_set_str(pinfo->cinfo, COL_INFO, "Authentication response from client"); + + proto_tree_add_item(tree, hf_vnc_auth_response, tvb, + offset, 16, ENC_NA); + + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SECURITY_RESULT; + break; + + case VNC_SESSION_STATE_ARD_AUTHENTICATION_CHALLENGE : + { + gint key_len; + + col_set_str(pinfo->cinfo, COL_INFO, "ARD authentication challenge"); + + proto_tree_add_item(tree, hf_vnc_ard_auth_generator, tvb, + offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_vnc_ard_auth_key_len, tvb, + offset + 2, 2, ENC_BIG_ENDIAN); + + key_len = tvb_get_ntohs(tvb, offset + 2); + + offset += 4; + + proto_tree_add_item(tree, hf_vnc_ard_auth_modulus, tvb, + offset, key_len, ENC_NA); + proto_tree_add_item(tree, hf_vnc_ard_auth_server_key, tvb, + offset + key_len, key_len, ENC_NA); + + per_conversation_info->ard_key_length = key_len; + per_conversation_info->vnc_next_state = + VNC_SESSION_STATE_ARD_AUTHENTICATION_RESPONSE; + } + break; + + case VNC_SESSION_STATE_ARD_AUTHENTICATION_RESPONSE : + col_set_str(pinfo->cinfo, COL_INFO, "ARD authentication response"); + + proto_tree_add_item(tree, hf_vnc_ard_auth_credentials, tvb, + offset, 128, ENC_NA); + proto_tree_add_item(tree, hf_vnc_ard_auth_client_key, tvb, + offset + 128, per_conversation_info->ard_key_length, ENC_NA); + + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SECURITY_RESULT; + break; + + case VNC_SESSION_STATE_SECURITY_RESULT : + col_set_str(pinfo->cinfo, COL_INFO, "Authentication result"); + + proto_tree_add_item(tree, hf_vnc_auth_result, tvb, offset, + 4, ENC_BIG_ENDIAN); + auth_result = tvb_get_ntohl(tvb, offset); + offset += 4; + + switch(auth_result) { + + case 0 : /* OK */ + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_INIT; + break; + + case 1 : /* Failed */ + if(per_conversation_info->client_proto_ver >= 3.008) { + text_len = tvb_get_ntohl(tvb, offset); + proto_tree_add_item(tree, hf_vnc_auth_error_length, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + proto_tree_add_item(tree, hf_vnc_auth_error, tvb, + offset, text_len, ENC_ASCII); + } + + return TRUE; /* All versions: Do not continue + processing VNC packets as connection + will be closed after this packet. */ + + break; + } + + break; + case VNC_SESSION_STATE_VENCRYPT_SERVER_VERSION: + { + proto_tree_add_item(tree, hf_vnc_vencrypt_server_major_ver, tvb, offset, 1, ENC_BIG_ENDIAN); + gint major = tvb_get_guint8(tvb, offset++); + proto_tree_add_item(tree, hf_vnc_vencrypt_server_minor_ver, tvb, offset, 1, ENC_BIG_ENDIAN); + gint minor = tvb_get_guint8(tvb, offset++); + col_add_fstr(pinfo->cinfo, COL_INFO, "VeNCrypt server version %d.%d", major, minor); + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VENCRYPT_CLIENT_VERSION; + break; + } + case VNC_SESSION_STATE_VENCRYPT_CLIENT_VERSION: + { + proto_tree_add_item(tree, hf_vnc_vencrypt_client_major_ver, tvb, offset, 1, ENC_BIG_ENDIAN); + gint major = tvb_get_guint8(tvb, offset++); + proto_tree_add_item(tree, hf_vnc_vencrypt_client_minor_ver, tvb, offset, 1, ENC_BIG_ENDIAN); + gint minor = tvb_get_guint8(tvb, offset++); + col_add_fstr(pinfo->cinfo, COL_INFO, "VeNCrypt client version %d.%d", major, minor); + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VENCRYPT_AUTH_CAPABILITIES; + break; + } + case VNC_SESSION_STATE_VENCRYPT_AUTH_CAPABILITIES: + { + gint i; + col_set_str(pinfo->cinfo, COL_INFO, "VeNCrypt authentication types supported"); + proto_tree_add_item(tree, hf_vnc_vencrypt_version_ack, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + proto_tree_add_item(tree, hf_vnc_vencrypt_num_auth_types, tvb, offset, 1, ENC_BIG_ENDIAN); + num_tunnel_types = tvb_get_guint8(tvb, offset); + offset += 1; + + for(i = 0; i < num_tunnel_types; i++) { + proto_tree_add_item(tree, hf_vnc_vencrypt_auth_type, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + } + + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VENCRYPT_AUTH_TYPE_REPLY; + break; + } + case VNC_SESSION_STATE_VENCRYPT_AUTH_TYPE_REPLY: + { + guint32 authtype = tvb_get_ntohl(tvb, offset); + col_add_fstr(pinfo->cinfo, COL_INFO, "VeNCrypt authentication type %s (%d) selected by client", + val_to_str_const(authtype, vnc_vencrypt_auth_types_vs, "Unknown"), + authtype); + proto_tree_add_item(tree, hf_vnc_vencrypt_auth_type, tvb, offset, 4, ENC_BIG_ENDIAN); + /* offset+=4; */ + if (authtype == VNC_SECURITY_TYPE_NONE) { + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_CLIENT_INIT; + per_conversation_info->security_type_selected = VNC_SECURITY_TYPE_NONE; + } else if (authtype == VNC_SECURITY_TYPE_VNC) { + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VNC_AUTHENTICATION_CHALLENGE; + per_conversation_info->security_type_selected = VNC_SECURITY_TYPE_VNC; + } else { + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_VENCRYPT_AUTH_ACK; + } + break; + } + case VNC_SESSION_STATE_VENCRYPT_AUTH_ACK: + col_set_str(pinfo->cinfo, COL_INFO, "VeNCrypt server ack"); + proto_tree_add_item(tree, hf_vnc_vencrypt_auth_type_ack, tvb, offset, 1, ENC_BIG_ENDIAN); + tls_handle = find_dissector("tls"); + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_NORMAL_TRAFFIC; + break; + + case VNC_SESSION_STATE_CLIENT_INIT : + col_set_str(pinfo->cinfo, COL_INFO, "Share desktop flag"); + + proto_tree_add_item(tree, hf_vnc_share_desktop_flag, tvb, + offset, 1, ENC_BIG_ENDIAN); + + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_SERVER_INIT; + + break; + + case VNC_SESSION_STATE_SERVER_INIT : + col_set_str(pinfo->cinfo, COL_INFO, "Server framebuffer parameters"); + + proto_tree_add_item(tree, hf_vnc_width, tvb, offset, 2, + ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_vnc_height, tvb, offset, 2, + ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_vnc_server_bits_per_pixel, + tvb, offset, 1, ENC_BIG_ENDIAN); + vnc_bytes_per_pixel = tvb_get_guint8(tvb, offset)/8; + vnc_set_bytes_per_pixel(pinfo, vnc_bytes_per_pixel); + offset += 1; + + proto_tree_add_item(tree, hf_vnc_server_depth, tvb, offset, + 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_vnc_server_big_endian_flag, + tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_vnc_server_true_color_flag, + tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_vnc_server_red_max, + tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_vnc_server_green_max, + tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_vnc_server_blue_max, + tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_vnc_server_red_shift, + tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_vnc_server_green_shift, + tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_vnc_server_blue_shift, + tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_vnc_padding, + tvb, offset, 3, ENC_NA); + offset += 3; /* Skip over 3 bytes of padding */ + + if(tvb_reported_length_remaining(tvb, offset) > 4) { + /* Sometimes the desktop name & length is skipped */ + proto_tree_add_item(tree, hf_vnc_desktop_name_len, + tvb, offset, 4, ENC_BIG_ENDIAN); + desktop_name_len = tvb_get_ntohl(tvb, offset); + offset += 4; + + proto_tree_add_item(tree, hf_vnc_desktop_name, + tvb, offset, desktop_name_len, + ENC_ASCII); + } + + if(per_conversation_info->tight_enabled == TRUE) + per_conversation_info->vnc_next_state = + VNC_SESSION_STATE_TIGHT_INTERACTION_CAPS; + else + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_NORMAL_TRAFFIC; + break; + + case VNC_SESSION_STATE_TIGHT_INTERACTION_CAPS : + col_set_str(pinfo->cinfo, COL_INFO, "TightVNC Interaction Capabilities"); + + proto_tree_add_item(tree, hf_vnc_num_server_message_types, + tvb, offset, 2, ENC_BIG_ENDIAN); + per_conversation_info->num_server_message_types = tvb_get_ntohs(tvb, offset); + offset += 2; + + proto_tree_add_item(tree, hf_vnc_num_client_message_types, + tvb, offset, 2, ENC_BIG_ENDIAN); + per_conversation_info->num_client_message_types = tvb_get_ntohs(tvb, offset); + offset += 2; + + proto_tree_add_item(tree, hf_vnc_num_encoding_types, + tvb, offset, 2, ENC_BIG_ENDIAN); + per_conversation_info->num_encoding_types = tvb_get_ntohs(tvb, offset); + offset += 2; + + proto_tree_add_item(tree, hf_vnc_padding, tvb, offset, 2, ENC_NA); + offset += 2; + + offset = process_tight_capabilities(tree, + hf_vnc_tight_server_message_type, + hf_vnc_tight_server_vendor, + hf_vnc_tight_server_name, + tvb, offset, per_conversation_info->num_server_message_types); + offset = process_tight_capabilities(tree, + hf_vnc_tight_client_message_type, + hf_vnc_tight_client_vendor, + hf_vnc_tight_client_name, + tvb, offset, per_conversation_info->num_client_message_types); + process_tight_capabilities(tree, + hf_vnc_tight_encoding_type, + hf_vnc_tight_encoding_vendor, + hf_vnc_tight_encoding_name, + tvb, offset, per_conversation_info->num_encoding_types); + + per_conversation_info->vnc_next_state = VNC_SESSION_STATE_NORMAL_TRAFFIC; + break; + + case VNC_SESSION_STATE_NORMAL_TRAFFIC : + return FALSE; + } + + return TRUE; +} + + +static void +vnc_client_to_server(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree) +{ + guint8 message_type; + + proto_item *ti; + proto_tree *vnc_client_message_type_tree; + + message_type = tvb_get_guint8(tvb, *offset); + + ti = proto_tree_add_item(tree, hf_vnc_client_message_type, tvb, + *offset, 1, ENC_BIG_ENDIAN); + + vnc_client_message_type_tree = + proto_item_add_subtree(ti, ett_vnc_client_message_type); + + *offset += 1; + + switch(message_type) { + + case VNC_CLIENT_MESSAGE_TYPE_SET_PIXEL_FORMAT : + vnc_client_set_pixel_format(tvb, pinfo, offset, + vnc_client_message_type_tree); + break; + + case VNC_CLIENT_MESSAGE_TYPE_SET_ENCODINGS : + vnc_client_set_encodings(tvb, pinfo, offset, + vnc_client_message_type_tree); + break; + + case VNC_CLIENT_MESSAGE_TYPE_FRAMEBUF_UPDATE_REQ : + vnc_client_framebuffer_update_request(tvb, pinfo, offset, + vnc_client_message_type_tree); + break; + + case VNC_CLIENT_MESSAGE_TYPE_KEY_EVENT : + vnc_client_key_event(tvb, pinfo, offset, + vnc_client_message_type_tree); + break; + + case VNC_CLIENT_MESSAGE_TYPE_POINTER_EVENT: + vnc_client_pointer_event(tvb, pinfo, offset, + vnc_client_message_type_tree); + break; + + case VNC_CLIENT_MESSAGE_TYPE_CLIENT_CUT_TEXT : + vnc_client_cut_text(tvb, pinfo, offset, + vnc_client_message_type_tree); + break; + + case VNC_CLIENT_MESSAGE_TYPE_MIRRORLINK : + vnc_mirrorlink(tvb, pinfo, offset, + vnc_client_message_type_tree); + break; + + case VNC_CLIENT_MESSAGE_TYPE_ENABLE_CONTINUOUS_UPDATES : + col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Client Enable Continuous Updates"); + *offset += 9; + break; + + case VNC_CLIENT_MESSAGE_TYPE_FENCE : + vnc_fence(tvb, pinfo, offset, + vnc_client_message_type_tree); + break; + + default : + col_append_sep_fstr(pinfo->cinfo, COL_INFO, "; ", + "Unknown client message type (%u)", + message_type); + break; + } +} + +static void +vnc_server_to_client(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree) +{ + gint start_offset; + guint8 message_type; + gint bytes_needed = 0; + + proto_item *ti; + proto_tree *vnc_server_message_type_tree; + +again: + start_offset = *offset; + + message_type = tvb_get_guint8(tvb, *offset); + + ti = proto_tree_add_item(tree, hf_vnc_server_message_type, tvb, + *offset, 1, ENC_BIG_ENDIAN); + vnc_server_message_type_tree = + proto_item_add_subtree(ti, ett_vnc_server_message_type); + + *offset += 1; + + switch(message_type) { + + case VNC_SERVER_MESSAGE_TYPE_FRAMEBUFFER_UPDATE : + bytes_needed = + vnc_server_framebuffer_update(tvb, pinfo, offset, + vnc_server_message_type_tree); + break; + + case VNC_SERVER_MESSAGE_TYPE_SET_COLORMAP_ENTRIES : + bytes_needed = vnc_server_set_colormap_entries(tvb, pinfo, offset, vnc_server_message_type_tree); + break; + + case VNC_SERVER_MESSAGE_TYPE_RING_BELL : + vnc_server_ring_bell(tvb, pinfo, offset, + vnc_server_message_type_tree); + break; + + case VNC_SERVER_MESSAGE_TYPE_CUT_TEXT : + bytes_needed = vnc_server_cut_text(tvb, pinfo, offset, + vnc_server_message_type_tree); + break; + + case VNC_SERVER_MESSAGE_TYPE_MIRRORLINK : + bytes_needed = vnc_mirrorlink(tvb, pinfo, offset, + vnc_server_message_type_tree); + break; + + case VNC_SERVER_MESSAGE_TYPE_END_CONTINUOUS_UPDATES : + col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Server End Continuous Updates"); + *offset += 1; + break; + + case VNC_SERVER_MESSAGE_TYPE_FENCE : + bytes_needed = vnc_fence(tvb, pinfo, offset, + vnc_server_message_type_tree); + break; + + default : + col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", + "Unknown server message type"); + *offset = tvb_reported_length(tvb); /* Swallow the rest of the segment */ + break; + } + + if(bytes_needed > 0 && vnc_preference_desegment && pinfo->can_desegment) { + proto_tree_add_expert(vnc_server_message_type_tree, pinfo, &ei_vnc_reassemble, tvb, start_offset, -1); + pinfo->desegment_offset = start_offset; + pinfo->desegment_len = DESEGMENT_ONE_MORE_SEGMENT; + return; + } + + if ((unsigned)*offset < tvb_reported_length(tvb)) { + goto again; + } +} + + +static void +vnc_client_set_pixel_format(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree) +{ + col_set_str(pinfo->cinfo, COL_INFO, "Client set pixel format"); + + proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 3, ENC_NA); + *offset += 3; /* Skip over 3 bytes of padding */ + + proto_tree_add_item(tree, hf_vnc_client_bits_per_pixel, tvb, *offset, + 1, ENC_BIG_ENDIAN); + vnc_bytes_per_pixel = tvb_get_guint8(tvb, *offset)/8; + vnc_set_bytes_per_pixel(pinfo, vnc_bytes_per_pixel); + *offset += 1; + + proto_tree_add_item(tree, hf_vnc_client_depth, tvb, *offset, + 1, ENC_BIG_ENDIAN); + vnc_depth = tvb_get_guint8(tvb, *offset); + vnc_set_depth(pinfo, vnc_depth); + *offset += 1; + + proto_tree_add_item(tree, hf_vnc_client_big_endian_flag, tvb, *offset, + 1, ENC_BIG_ENDIAN); + *offset += 1; + + proto_tree_add_item(tree, hf_vnc_client_true_color_flag, tvb, *offset, + 1, ENC_BIG_ENDIAN); + *offset += 1; + + proto_tree_add_item(tree, hf_vnc_client_red_max, tvb, *offset, + 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(tree, hf_vnc_client_green_max, tvb, *offset, + 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(tree, hf_vnc_client_blue_max, tvb, *offset, + 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(tree, hf_vnc_client_red_shift, tvb, *offset, + 1, ENC_BIG_ENDIAN); + *offset += 1; + + proto_tree_add_item(tree, hf_vnc_client_green_shift, tvb, *offset, + 1, ENC_BIG_ENDIAN); + *offset += 1; + + proto_tree_add_item(tree, hf_vnc_client_blue_shift, tvb, *offset, + 1, ENC_BIG_ENDIAN); + *offset += 1; + + proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 3, ENC_NA); + *offset += 3; /* Skip over 3 bytes of padding */ +} + + +static void +vnc_client_set_encodings(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree) +{ + guint16 number_of_encodings; + guint counter; + vnc_packet_t *per_packet_info; + + per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); + /* Our calling function should have set the packet's proto data already */ + DISSECTOR_ASSERT(per_packet_info != NULL); + + col_set_str(pinfo->cinfo, COL_INFO, "Client set encodings"); + + proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 1, ENC_NA); + *offset += 1; /* Skip over 1 byte of padding */ + + number_of_encodings = tvb_get_ntohs(tvb, *offset); + proto_tree_add_item(tree, hf_vnc_encoding_num, tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + per_packet_info->preferred_encoding = -1; + + for(counter = 0; counter < number_of_encodings; counter++) { + proto_tree_add_item(tree, + hf_vnc_client_set_encodings_encoding_type, + tvb, *offset, 4, ENC_BIG_ENDIAN); + + /* Remember the first real encoding as the preferred encoding, + * per xserver/hw/vnc/rfbserver.c:rfbProcessClientNormalMessage(). + * Otherwise, use RAW as the preferred encoding. + */ + if (per_packet_info->preferred_encoding == -1) { + int encoding; + + encoding = tvb_get_ntohl(tvb, *offset); + + switch(encoding) { + case VNC_ENCODING_TYPE_RAW: + case VNC_ENCODING_TYPE_RRE: + case VNC_ENCODING_TYPE_CORRE: + case VNC_ENCODING_TYPE_HEXTILE: + case VNC_ENCODING_TYPE_ZLIB: + case VNC_ENCODING_TYPE_TIGHT: + per_packet_info->preferred_encoding = encoding; + break; + } + } + + *offset += 4; + } + + if (per_packet_info->preferred_encoding == -1) + per_packet_info->preferred_encoding = VNC_ENCODING_TYPE_RAW; +} + + +static void +vnc_client_framebuffer_update_request(tvbuff_t *tvb, packet_info *pinfo, + gint *offset, proto_tree *tree) +{ + col_set_str(pinfo->cinfo, COL_INFO, "Client framebuffer update request"); + + proto_tree_add_item(tree, hf_vnc_update_req_incremental, + tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + + proto_tree_add_item(tree, hf_vnc_update_req_x_pos, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(tree, hf_vnc_update_req_y_pos, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(tree, hf_vnc_update_req_width, tvb, + *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(tree, hf_vnc_update_req_height, tvb, + *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; +} + + +static void +vnc_client_key_event(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree) +{ + col_set_str(pinfo->cinfo, COL_INFO, "Client key event"); + + proto_tree_add_item(tree, hf_vnc_key_down, tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + + proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 2, ENC_NA); + *offset += 2; /* Skip over 2 bytes of padding */ + + proto_tree_add_item(tree, hf_vnc_key, tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; +} + + +static void +vnc_client_pointer_event(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree) +{ + col_set_str(pinfo->cinfo, COL_INFO, "Client pointer event"); + + proto_tree_add_item(tree, hf_vnc_button_1_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_vnc_button_2_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_vnc_button_3_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_vnc_button_4_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_vnc_button_5_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_vnc_button_6_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_vnc_button_7_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_vnc_button_8_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + + proto_tree_add_item(tree, hf_vnc_pointer_x_pos, tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(tree, hf_vnc_pointer_y_pos, tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; +} + + +static void +vnc_client_cut_text(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree) +{ + guint32 text_len; + + col_set_str(pinfo->cinfo, COL_INFO, "Client cut text"); + + proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 3, ENC_NA); + *offset += 3; /* Skip over 3 bytes of padding */ + + text_len = tvb_get_ntohl(tvb, *offset); + proto_tree_add_item(tree, hf_vnc_client_cut_text_len, tvb, *offset, 4, + ENC_BIG_ENDIAN); + *offset += 4; + + proto_tree_add_item(tree, hf_vnc_client_cut_text, tvb, *offset, + text_len, ENC_ASCII); + *offset += text_len; + +} + + +static guint +vnc_server_framebuffer_update(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree) +{ + guint ii; + guint num_rects; + guint16 width, height; + guint bytes_needed = 0; + guint32 encoding_type; + proto_item *ti, *ti_x, *ti_y, *ti_width, *ti_height; + proto_tree *vnc_rect_tree, *vnc_encoding_type_tree; + + col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Server framebuffer update"); + + proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 1, ENC_NA); + *offset += 1; + + num_rects = tvb_get_ntohs(tvb, *offset); + ti = proto_tree_add_item(tree, hf_vnc_rectangle_num, tvb, *offset, 2, ENC_BIG_ENDIAN); + + /* In some cases, TIGHT encoding ignores the "number of rectangles" field; */ + /* VNC_ENCODING_TYPE_LAST_RECT is used to indicate the end of the rectangle list. */ + /* (It appears that TIGHT encoding uses 0xFFFF for the num_rects field when the */ + /* field is not being used). For now: we'll assume that a value 0f 0xFFFF means */ + /* that the field is not being used. */ + if (num_rects == 0xFFFF) { + proto_item_append_text(ti, " [TIGHT encoding assumed (field is not used)]"); + } + if ((num_rects != 0xFFFF) && (num_rects > 5000)) { + expert_add_info_format(pinfo, ti, &ei_vnc_too_many_rectangles, + "Too many rectangles (%d), aborting dissection", num_rects); + return(0); + } + + *offset += 2; + + for(ii = 0; ii < num_rects; ii++) { + if (ii > 5000) { + expert_add_info_format(pinfo, ti, &ei_vnc_too_many_rectangles, + "Too many rectangles (%d), aborting dissection", ii); + return(0); + } + VNC_BYTES_NEEDED(12); + + vnc_rect_tree = proto_tree_add_subtree_format(tree, tvb, *offset, 12, + ett_vnc_rect, NULL, "Rectangle #%d", ii+1); + + + ti_x = proto_tree_add_item(vnc_rect_tree, hf_vnc_fb_update_x_pos, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + ti_y = proto_tree_add_item(vnc_rect_tree, hf_vnc_fb_update_y_pos, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + ti_width = proto_tree_add_item(vnc_rect_tree, hf_vnc_fb_update_width, + tvb, *offset, 2, ENC_BIG_ENDIAN); + width = tvb_get_ntohs(tvb, *offset); + *offset += 2; + + ti_height = proto_tree_add_item(vnc_rect_tree, hf_vnc_fb_update_height, + tvb, *offset, 2, ENC_BIG_ENDIAN); + height = tvb_get_ntohs(tvb, *offset); + *offset += 2; + + ti = proto_tree_add_item(vnc_rect_tree, + hf_vnc_fb_update_encoding_type, + tvb, *offset, 4, ENC_BIG_ENDIAN); + + encoding_type = tvb_get_ntohl(tvb, *offset); + *offset += 4; + + if (encoding_type == VNC_ENCODING_TYPE_LAST_RECT) + break; /* exit the loop */ + + vnc_encoding_type_tree = + proto_item_add_subtree(ti, ett_vnc_encoding_type); + + switch(encoding_type) { + + case VNC_ENCODING_TYPE_RAW: + bytes_needed = vnc_raw_encoding(tvb, pinfo, offset, + vnc_encoding_type_tree, + width, height); + break; + + case VNC_ENCODING_TYPE_COPY_RECT: + bytes_needed = + vnc_copyrect_encoding(tvb, pinfo, offset, + vnc_encoding_type_tree, + width, height); + break; + + case VNC_ENCODING_TYPE_RRE: + bytes_needed = + vnc_rre_encoding(tvb, pinfo, offset, + vnc_encoding_type_tree, + width, height); + break; + + case VNC_ENCODING_TYPE_HEXTILE: + bytes_needed = + vnc_hextile_encoding(tvb, pinfo, offset, + vnc_encoding_type_tree, + width, height); + break; + + case VNC_ENCODING_TYPE_RLE: + bytes_needed = + vnc_zrle_encoding(tvb, pinfo, offset, + vnc_encoding_type_tree, + width, height); + break; + + case VNC_ENCODING_TYPE_TIGHT: + bytes_needed = + vnc_tight_encoding(tvb, pinfo, offset, + vnc_encoding_type_tree, + width, height); + break; + + case VNC_ENCODING_TYPE_RICH_CURSOR: + case VNC_ENCODING_TYPE_X_CURSOR: + proto_item_append_text (ti_x, " (hotspot X)"); + proto_item_append_text (ti_y, " (hotspot Y)"); + proto_item_append_text (ti_width, " (cursor width)"); + proto_item_append_text (ti_height, " (cursor height)"); + + if (encoding_type == VNC_ENCODING_TYPE_RICH_CURSOR) + bytes_needed = vnc_rich_cursor_encoding(tvb, pinfo, offset, vnc_encoding_type_tree, width, height); + else + bytes_needed = vnc_x_cursor_encoding(tvb, pinfo, offset, vnc_encoding_type_tree, width, height); + + break; + + case VNC_ENCODING_TYPE_POINTER_POS: + proto_item_append_text (ti_x, " (pointer X)"); + proto_item_append_text (ti_y, " (pointer Y)"); + proto_item_append_text (ti_width, " (unused)"); + proto_item_append_text (ti_height, " (unused)"); + bytes_needed = 0; + break; + + case VNC_ENCODING_TYPE_DESKTOP_SIZE: + + /* There is no payload for this message type */ + + bytes_needed = 0; + break; + + case VNC_ENCODING_TYPE_EXTENDED_DESK_SIZE : + bytes_needed = vnc_extended_desktop_size(tvb, offset, vnc_encoding_type_tree); + break; + + case VNC_ENCODING_TYPE_KEYBOARD_LED_STATE : + + /* There is no payload for this message type */ + + bytes_needed = 0; + break; + + case VNC_ENCODING_TYPE_SUPPORTED_MESSAGES : + bytes_needed = vnc_supported_messages(tvb, offset, + vnc_encoding_type_tree, + width); + break; + + case VNC_ENCODING_TYPE_SUPPORTED_ENCODINGS : + bytes_needed = vnc_supported_encodings(tvb, offset, + vnc_encoding_type_tree, + width, height); + break; + + case VNC_ENCODING_TYPE_SERVER_IDENTITY : + bytes_needed = vnc_server_identity(tvb, offset, + vnc_encoding_type_tree, + width); + break; + + case VNC_ENCODING_TYPE_CONTEXT_INFORMATION : + bytes_needed = vnc_context_information(tvb, offset, + vnc_encoding_type_tree); + break; + + case VNC_ENCODING_TYPE_SLRLE : + bytes_needed = vnc_slrle_encoding(tvb, pinfo, offset, + vnc_encoding_type_tree, + height); + break; + + case VNC_ENCODING_TYPE_H264 : + bytes_needed = vnc_h264_encoding(tvb, offset, + vnc_encoding_type_tree); + break; + + } + + /* Check if the routines above requested more bytes to + * be desegmented. */ + if(bytes_needed > 0) + return bytes_needed; + } + + return 0; +} + +static guint32 +vnc_extended_desktop_size(tvbuff_t *tvb, gint *offset, proto_tree *tree) +{ + + guint8 i, num_of_screens; + proto_tree *screen_tree; + + num_of_screens = tvb_get_guint8(tvb, *offset); + proto_tree_add_item(tree, hf_vnc_desktop_screen_num, tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 3, ENC_NA); + + VNC_BYTES_NEEDED((guint32)(3 + (num_of_screens * 16))); + *offset += 3; + for(i = 0; i < num_of_screens; i++) { + screen_tree = proto_tree_add_subtree_format(tree, tvb, *offset, 16, ett_vnc_desktop_screen, NULL, "Screen #%u", i+1); + + proto_tree_add_item(screen_tree, hf_vnc_desktop_screen_id, tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + proto_tree_add_item(screen_tree, hf_vnc_desktop_screen_x, tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(screen_tree, hf_vnc_desktop_screen_y, tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(screen_tree, hf_vnc_desktop_screen_width, tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(screen_tree, hf_vnc_desktop_screen_height, tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(screen_tree, hf_vnc_desktop_screen_flags, tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + } + + return 0; +} + +static guint +vnc_raw_encoding(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, const guint16 width, const guint16 height) +{ + guint8 bytes_per_pixel = vnc_get_bytes_per_pixel(pinfo); + guint length; + + length = width * height * bytes_per_pixel; + VNC_BYTES_NEEDED(length); + + proto_tree_add_item(tree, hf_vnc_raw_pixel_data, tvb, *offset, + length, ENC_NA); + *offset += length; + + return 0; /* bytes_needed */ +} + + +static guint +vnc_copyrect_encoding(tvbuff_t *tvb, packet_info *pinfo _U_, gint *offset, + proto_tree *tree, const guint16 width _U_, const guint16 height _U_) +{ + proto_tree_add_item(tree, hf_vnc_copyrect_src_x_pos, tvb, *offset, + 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(tree, hf_vnc_copyrect_src_y_pos, tvb, *offset, + 2, ENC_BIG_ENDIAN); + *offset += 2; + + return 0; /* bytes_needed */ +} + + +static guint +vnc_rre_encoding(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, const guint16 width _U_, const guint16 height _U_) +{ + guint8 bytes_per_pixel = vnc_get_bytes_per_pixel(pinfo); + guint32 num_subrects, i; + guint bytes_needed; + proto_item *ti; + proto_tree *subrect_tree; + + VNC_BYTES_NEEDED(4); + ti = proto_tree_add_item(tree, hf_vnc_rre_num_subrects, tvb, *offset, + 4, ENC_BIG_ENDIAN); + num_subrects = tvb_get_ntohl(tvb, *offset); + *offset += 4; + + if (num_subrects > 10000) { + expert_add_info_format(pinfo, ti, &ei_vnc_too_many_sub_rectangles, + "Too many sub-rectangles (%d), aborting dissection", num_subrects); + return(0); + } + + VNC_BYTES_NEEDED(bytes_per_pixel); + proto_tree_add_item(tree, hf_vnc_rre_bg_pixel, tvb, *offset, + bytes_per_pixel, ENC_NA); + *offset += bytes_per_pixel; + + /* We know we need (at least) all these bytes, so ask for them now + * (instead of a few at a time...). + */ + bytes_needed = bytes_per_pixel + 8; + VNC_BYTES_NEEDED(bytes_needed * num_subrects); + for(i = 0; i < num_subrects; i++) { + + subrect_tree = proto_tree_add_subtree_format(tree, tvb, *offset, bytes_per_pixel + + 8, ett_vnc_rre_subrect, NULL, "Subrectangle #%d", i+1); + + proto_tree_add_item(subrect_tree, hf_vnc_rre_subrect_pixel, + tvb, *offset, bytes_per_pixel, ENC_NA); + *offset += bytes_per_pixel; + + proto_tree_add_item(subrect_tree, hf_vnc_rre_subrect_x_pos, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(subrect_tree, hf_vnc_rre_subrect_y_pos, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(subrect_tree, hf_vnc_rre_subrect_width, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(subrect_tree, hf_vnc_rre_subrect_height, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + } + + return 0; /* bytes_needed */ +} + + +static guint +vnc_hextile_encoding(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, const guint16 width, const guint16 height) +{ + guint8 bytes_per_pixel = vnc_get_bytes_per_pixel(pinfo); + guint8 i, subencoding_mask, num_subrects, subrect_len, tile_height, tile_width; + guint32 raw_length; + proto_tree *tile_tree, *subencoding_mask_tree, *subrect_tree, *num_subrects_tree; + proto_item *ti; + guint16 current_height = 0, current_width; + + while(current_height != height) { + if (current_height + 16 > height) + tile_height = height - current_height; + else + tile_height = 16; + current_height += tile_height; + current_width = 0; + while(current_width != width) { + if (current_width + 16 > width) + tile_width = width - current_width; + else + tile_width = 16; + + current_width += tile_width; + + VNC_BYTES_NEEDED(1); + subencoding_mask = tvb_get_guint8(tvb, *offset); + + tile_tree = proto_tree_add_subtree_format(tree, tvb, *offset, 1, ett_vnc_hextile_tile, NULL, + "Tile {%d:%d}, sub encoding mask %u", current_width, current_height, subencoding_mask); + + ti = proto_tree_add_item(tile_tree, hf_vnc_hextile_subencoding_mask, tvb, + *offset, 1, ENC_BIG_ENDIAN); + + subencoding_mask_tree = + proto_item_add_subtree(ti, ett_vnc_hextile_subencoding_mask); + + proto_tree_add_item(subencoding_mask_tree, + hf_vnc_hextile_raw, tvb, *offset, 1, + ENC_BIG_ENDIAN); + proto_tree_add_item(subencoding_mask_tree, + hf_vnc_hextile_bg, tvb, *offset, 1, + ENC_BIG_ENDIAN); + proto_tree_add_item(subencoding_mask_tree, + hf_vnc_hextile_fg, tvb, *offset, 1, + ENC_BIG_ENDIAN); + proto_tree_add_item(subencoding_mask_tree, + hf_vnc_hextile_anysubrects, tvb, *offset, 1, + ENC_BIG_ENDIAN); + proto_tree_add_item(subencoding_mask_tree, + hf_vnc_hextile_subrectscolored, tvb, *offset, 1, + ENC_BIG_ENDIAN); + *offset += 1; + + if(subencoding_mask & 0x1) { /* Raw */ + raw_length = tile_width * tile_height * bytes_per_pixel; + + VNC_BYTES_NEEDED(raw_length); + proto_tree_add_item(tile_tree, hf_vnc_hextile_raw_value, tvb, + *offset, raw_length, ENC_NA); + *offset += raw_length; + } else { + if(subencoding_mask & 0x2) { /* Background Specified */ + VNC_BYTES_NEEDED(bytes_per_pixel); + proto_tree_add_item(tile_tree, hf_vnc_hextile_bg_value, + tvb, *offset, bytes_per_pixel, + ENC_NA); + *offset += bytes_per_pixel; + } + + if(subencoding_mask & 0x4) { /* Foreground Specified */ + VNC_BYTES_NEEDED(bytes_per_pixel); + proto_tree_add_item(tile_tree, hf_vnc_hextile_fg_value, + tvb, *offset, bytes_per_pixel, + ENC_NA); + *offset += bytes_per_pixel; + } + + if(subencoding_mask & 0x8) { /* Any Subrects */ + VNC_BYTES_NEEDED(3); /* 1 byte for number of subrects field, +2 at least for 1 subrect */ + ti = proto_tree_add_item(tile_tree, + hf_vnc_hextile_num_subrects, + tvb, *offset, 1, + ENC_BIG_ENDIAN); + num_subrects = tvb_get_guint8(tvb, *offset); + *offset += 1; + + if(subencoding_mask & 0x10) + subrect_len = bytes_per_pixel + 2; + else + subrect_len = 2; + VNC_BYTES_NEEDED((guint)(subrect_len * num_subrects)); + + num_subrects_tree = + proto_item_add_subtree(ti, ett_vnc_hextile_num_subrects); + + for(i = 0; i < num_subrects; i++) { + subrect_tree = proto_tree_add_subtree_format(num_subrects_tree, tvb, + *offset, subrect_len, ett_vnc_hextile_subrect, NULL, + "Subrectangle #%d", i+1); + + if(subencoding_mask & 0x10) { + /* Subrects Colored */ + proto_tree_add_item(subrect_tree, hf_vnc_hextile_subrect_pixel_value, tvb, *offset, bytes_per_pixel, ENC_NA); + + *offset += bytes_per_pixel; + } + + proto_tree_add_item(subrect_tree, + hf_vnc_hextile_subrect_x_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); + + proto_tree_add_item(subrect_tree, hf_vnc_hextile_subrect_y_pos, tvb, *offset, 1, ENC_BIG_ENDIAN); + + *offset += 1; + + proto_tree_add_item(subrect_tree, hf_vnc_hextile_subrect_width, tvb, *offset, 1, ENC_BIG_ENDIAN); + + proto_tree_add_item(subrect_tree, hf_vnc_hextile_subrect_height, tvb, *offset, 1, ENC_BIG_ENDIAN); + + *offset += 1; + } + } + } + } + } + return 0; /* bytes_needed */ +} + +static guint +vnc_supported_messages(tvbuff_t *tvb, gint *offset, proto_tree *tree, + const guint16 width) +{ + VNC_BYTES_NEEDED(width); + if (width >= 64) { + proto_tree_add_item(tree, + hf_vnc_supported_messages_client2server, + tvb, *offset, 32, ENC_NA); + *offset += 32; + proto_tree_add_item(tree, + hf_vnc_supported_messages_server2client, + tvb, *offset, 32, ENC_NA); + *offset += 32; + *offset += width - 64; + } else { + *offset += width; + } + + return 0; /* bytes_needed */ +} + +static guint +vnc_supported_encodings(tvbuff_t *tvb, gint *offset, proto_tree *tree, + const guint16 width, const guint16 height) +{ + guint16 i = width; + + proto_tree_add_uint(tree, hf_vnc_num_supported_encodings, tvb, *offset, 0, height); + + VNC_BYTES_NEEDED(width); + for (; i >= 4; i -= 4) { + proto_tree_add_item(tree, hf_vnc_supported_encodings, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + } + *offset += i; + + return 0; /* bytes_needed */ +} + +static guint +vnc_server_identity(tvbuff_t *tvb, gint *offset, proto_tree *tree, + const guint16 width) +{ + VNC_BYTES_NEEDED(width); + proto_tree_add_item(tree, hf_vnc_server_identity, + tvb, *offset, width, ENC_ASCII); + *offset += width; + + return 0; /* bytes_needed */ +} + +static guint +vnc_mirrorlink(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree) +{ + guint8 type; + guint16 length; + guint16 num, i; + gint end; + proto_tree *sub_tree; + + /* Header */ + VNC_BYTES_NEEDED(3); + + type = tvb_get_guint8(tvb, *offset); + proto_tree_add_item(tree, hf_vnc_mirrorlink_type, + tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + + length = tvb_get_ntohs(tvb, *offset); + proto_tree_add_item(tree, hf_vnc_mirrorlink_length, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + col_add_fstr(pinfo->cinfo, COL_INFO, "MirrorLink (%s)", + val_to_str_const(type, vnc_mirrorlink_types_vs, + "Unknown")); + + /* Payload */ + end = *offset + length; + + switch(type) { + + case VNC_ML_EXT_BYE_BYE : + break; + + case VNC_ML_EXT_SERVER_DISPLAY_CONFIGURATION : + VNC_BYTES_NEEDED(12); + proto_tree_add_item(tree, hf_vnc_mirrorlink_version_major, + tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + proto_tree_add_item(tree, hf_vnc_mirrorlink_version_minor, + tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + proto_tree_add_item(tree, + hf_vnc_mirrorlink_framebuffer_configuration, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_pixel_width, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_pixel_height, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_pixel_format, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + break; + + case VNC_ML_EXT_CLIENT_DISPLAY_CONFIGURATION : + VNC_BYTES_NEEDED(14); + proto_tree_add_item(tree, hf_vnc_mirrorlink_version_major, + tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + proto_tree_add_item(tree, hf_vnc_mirrorlink_version_minor, + tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + proto_tree_add_item(tree, + hf_vnc_mirrorlink_framebuffer_configuration, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_pixel_width, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_pixel_height, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_display_width, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_display_height, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_display_distance, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + break; + + case VNC_ML_EXT_SERVER_EVENT_CONFIGURATION : + case VNC_ML_EXT_CLIENT_EVENT_CONFIGURATION : + VNC_BYTES_NEEDED(28); + proto_tree_add_item(tree, hf_vnc_mirrorlink_keyboard_language, + tvb, *offset, 2, ENC_ASCII); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_keyboard_country, + tvb, *offset, 2, ENC_ASCII); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_ui_language, + tvb, *offset, 2, ENC_ASCII); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_ui_country, + tvb, *offset, 2, ENC_ASCII); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_knob_keys, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + proto_tree_add_item(tree, hf_vnc_mirrorlink_device_keys, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + proto_tree_add_item(tree, hf_vnc_mirrorlink_multimedia_keys, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + proto_tree_add_item(tree, hf_vnc_mirrorlink_key_related, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + proto_tree_add_item(tree, hf_vnc_mirrorlink_pointer_related, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + break; + + case VNC_ML_EXT_EVENT_MAPPING : + case VNC_ML_EXT_EVENT_MAPPING_REQUEST : + VNC_BYTES_NEEDED(8); + proto_tree_add_item(tree, + hf_vnc_mirrorlink_key_symbol_value_client, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + proto_tree_add_item(tree, + hf_vnc_mirrorlink_key_symbol_value_server, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + break; + + case VNC_ML_EXT_KEY_EVENT_LISTING : + VNC_BYTES_NEEDED(4); + proto_tree_add_item(tree, hf_vnc_mirrorlink_key_configuration, + tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + num = tvb_get_guint8(tvb, *offset); + proto_tree_add_item(tree, hf_vnc_mirrorlink_key_num_events, + tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + proto_tree_add_item(tree, hf_vnc_mirrorlink_key_event_counter, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + VNC_BYTES_NEEDED((guint)(4 * num)); + sub_tree = proto_tree_add_subtree(tree, tvb, *offset, 4 * num, + ett_vnc_key_events, NULL, "Key Event List"); + for (; num > 0; num--) { + proto_tree_add_item(sub_tree, + hf_vnc_mirrorlink_key_symbol_value, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4 ; + } + break; + + case VNC_ML_EXT_KEY_EVENT_LISTING_REQUEST : + VNC_BYTES_NEEDED(4); + proto_tree_add_item(tree, + hf_vnc_mirrorlink_key_request_configuration, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + break; + + case VNC_ML_EXT_VIRTUAL_KEYBOARD : + VNC_BYTES_NEEDED(16); + proto_tree_add_item(tree, + hf_vnc_mirrorlink_keyboard_configuration, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + proto_tree_add_item(tree, hf_vnc_mirrorlink_cursor_x, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_cursor_y, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_text_x, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_text_y, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_text_width, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_text_height, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + break; + + case VNC_ML_EXT_VIRTUAL_KEYBOARD_REQUEST : + VNC_BYTES_NEEDED(4); + proto_tree_add_item(tree, + hf_vnc_mirrorlink_keyboard_request_configuration, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + break; + + case VNC_ML_EXT_DEVICE_STATUS : + case VNC_ML_EXT_DEVICE_STATUS_REQUEST : + VNC_BYTES_NEEDED(4); + proto_tree_add_item(tree, hf_vnc_mirrorlink_device_status, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + break; +/* + case VNC_ML_EXT_CONTENT_ATTESTATION : + break; + + case VNC_ML_EXT_CONTENT_ATTESTATION_REQUEST : + break; +*/ + case VNC_ML_EXT_FB_BLOCKING_NOTIFICATION : + VNC_BYTES_NEEDED(14); + proto_tree_add_item(tree, hf_vnc_mirrorlink_fb_block_x, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_fb_block_y, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_fb_block_width, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_fb_block_height, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(tree, hf_vnc_mirrorlink_app_id, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + proto_tree_add_item(tree, hf_vnc_mirrorlink_fb_block_reason, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + break; + + case VNC_ML_EXT_AUDIO_BLOCKING_NOTIFICATION : + VNC_BYTES_NEEDED(6); + proto_tree_add_item(tree, hf_vnc_mirrorlink_app_id, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + proto_tree_add_item(tree, hf_vnc_mirrorlink_audio_block_reason, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + break; + + case VNC_ML_EXT_TOUCH_EVENT : + VNC_BYTES_NEEDED(1); + num = tvb_get_guint8(tvb, *offset); + proto_tree_add_item(tree, hf_vnc_mirrorlink_touch_num_events, + tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + VNC_BYTES_NEEDED((guint)(6 * num)); + /*sub_tree = proto_item_add_subtree(tree, ett_vnc_touch_events);*/ + for (i = 0; i < num; i++) { + sub_tree = proto_tree_add_subtree_format(tree, tvb, *offset, 6, + ett_vnc_touch_events, NULL, "Touch Event #%d", i + 1); + + proto_tree_add_item(sub_tree, hf_vnc_mirrorlink_touch_x, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(sub_tree, hf_vnc_mirrorlink_touch_y, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + proto_tree_add_item(sub_tree, + hf_vnc_mirrorlink_touch_id, + tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + proto_tree_add_item(sub_tree, + hf_vnc_mirrorlink_touch_pressure, + tvb, *offset, 1, ENC_BIG_ENDIAN); + *offset += 1; + } + break; + + case VNC_ML_EXT_FB_ALTERNATIVE_TEXT : + VNC_BYTES_NEEDED(6); + proto_tree_add_item(tree, hf_vnc_mirrorlink_app_id, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + num = tvb_get_ntohs(tvb, *offset); + proto_tree_add_item(tree, hf_vnc_mirrorlink_text_length, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + VNC_BYTES_NEEDED(num); + proto_tree_add_item(tree, hf_vnc_mirrorlink_text, + tvb, *offset, num, ENC_ASCII); + *offset += num; + break; + + case VNC_ML_EXT_FB_ALTERNATIVE_TEXT_REQUEST : + VNC_BYTES_NEEDED(2); + proto_tree_add_item(tree, hf_vnc_mirrorlink_text_max_length, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + break; + + } + + if (end > *offset) { + length = end - *offset; + VNC_BYTES_NEEDED(length); + proto_tree_add_item(tree, hf_vnc_mirrorlink_unknown, + tvb, *offset, length, ENC_NA); + *offset = end; + } + + return 0; /* bytes_needed */ +} + +static guint +vnc_fence(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree) +{ + guint payload_length; + + VNC_BYTES_NEEDED(8); + + payload_length = tvb_get_guint8(tvb, *offset+7); + VNC_BYTES_NEEDED((8+payload_length)); + + col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Fence"); + + proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 3, ENC_NA); + *offset += 3; /* skip padding */ + + proto_tree_add_bitmask(tree, tvb, *offset, hf_vnc_fence_flags, + ett_vnc_fence_flags, vnc_fence_flags, ENC_BIG_ENDIAN); + + *offset += 4; + + proto_tree_add_item(tree, hf_vnc_fence_payload_length, + tvb, *offset, 1, ENC_BIG_ENDIAN); + + *offset += 1; + + if (payload_length > 0) { + proto_tree_add_item(tree, hf_vnc_fence_payload, + tvb, *offset, payload_length, ENC_NA); + *offset += payload_length; + } + return 0; +} + +static guint +vnc_context_information(tvbuff_t *tvb, gint *offset, proto_tree *tree) +{ + VNC_BYTES_NEEDED(20); + + proto_tree_add_item(tree, hf_vnc_context_information_app_id, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + + proto_tree_add_item(tree, hf_vnc_context_information_app_trust_level, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(tree, + hf_vnc_context_information_content_trust_level, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(tree, hf_vnc_context_information_app_category, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + + proto_tree_add_item(tree, hf_vnc_context_information_content_category, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + + proto_tree_add_item(tree, hf_vnc_context_information_content_rules, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + + return 0; /* bytes_needed */ +} + +static guint +vnc_slrle_encoding(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, const guint16 height) +{ + guint8 depth = vnc_get_depth(pinfo); + guint8 depth_mod = depth % 8; + guint8 bytes_per_run; + guint16 num_runs, i; + guint length; + proto_tree *sub_tree; + + if (depth_mod <= 4) + bytes_per_run = ( 8 - depth_mod + depth) / 8; + else + bytes_per_run = (16 - depth_mod + depth) / 8; + + for (i = 0; i < height; i++) { + VNC_BYTES_NEEDED(2); + num_runs = tvb_get_ntohs(tvb, *offset); + + length = num_runs * bytes_per_run; + + sub_tree = proto_tree_add_subtree_format(tree, tvb, *offset, 2 + length, + ett_vnc_slrle_subline, NULL, "Scanline #%d", i+1); + + proto_tree_add_item(sub_tree, hf_vnc_slrle_run_num, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + VNC_BYTES_NEEDED(length); + proto_tree_add_item(sub_tree, hf_vnc_slrle_run_data, + tvb, *offset, length, ENC_NA); + *offset += length; + } + + return 0; /* bytes_needed */ +} + +static guint +vnc_h264_encoding(tvbuff_t *tvb, gint *offset, proto_tree *tree) +{ + guint32 nbytes; + + VNC_BYTES_NEEDED(16); + + nbytes = tvb_get_ntohl(tvb, *offset); + proto_tree_add_item(tree, hf_vnc_h264_nbytes, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + + /*0 == P-Frame; 1 == B-Frame; 2 == I-Frame*/ + proto_tree_add_item(tree, hf_vnc_h264_slice_type, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + + proto_tree_add_item(tree, hf_vnc_h264_width, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + + proto_tree_add_item(tree, hf_vnc_h264_height, + tvb, *offset, 4, ENC_BIG_ENDIAN); + *offset += 4; + + VNC_BYTES_NEEDED(nbytes); + proto_tree_add_item(tree, hf_vnc_h264_data, + tvb, *offset, nbytes, ENC_NA); + *offset += nbytes; + + return 0; /* bytes_needed */ +} + +#ifdef HAVE_ZLIB +static guint +vnc_zrle_encoding(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, const guint16 width, const guint16 height) +#else +static guint +vnc_zrle_encoding(tvbuff_t *tvb, packet_info *pinfo _U_, gint *offset, + proto_tree *tree, const guint16 width _U_, const guint16 height _U_) +#endif +{ + guint32 data_len; +#ifdef HAVE_ZLIB + guint8 palette_size; + guint8 bytes_per_cpixel = vnc_get_bytes_per_pixel(pinfo); + gint uncomp_offset = 0; + guint length; + gint subencoding_type; + tvbuff_t *uncomp_tvb; + proto_tree *zrle_subencoding_tree; + proto_item *ti; +#endif + + VNC_BYTES_NEEDED(4); + proto_tree_add_item(tree, hf_vnc_zrle_len, tvb, *offset, + 4, ENC_BIG_ENDIAN); + data_len = tvb_get_ntohl(tvb, *offset); + + *offset += 4; + + VNC_BYTES_NEEDED(data_len); + + proto_tree_add_item(tree, hf_vnc_zrle_data, tvb, *offset, + data_len, ENC_NA); + +#ifdef HAVE_ZLIB + uncomp_tvb = tvb_child_uncompress(tvb, tvb, *offset, data_len); + + if(uncomp_tvb != NULL) { + add_new_data_source(pinfo, uncomp_tvb, + "Uncompressed ZRLE data"); + + ti = proto_tree_add_item(tree, hf_vnc_zrle_subencoding, + uncomp_tvb, uncomp_offset, 1, ENC_BIG_ENDIAN); + zrle_subencoding_tree = + proto_item_add_subtree(ti, ett_vnc_zrle_subencoding); + + proto_tree_add_item(zrle_subencoding_tree, hf_vnc_zrle_rle, + uncomp_tvb, uncomp_offset, 1, ENC_BIG_ENDIAN); + + proto_tree_add_item(zrle_subencoding_tree, + hf_vnc_zrle_palette_size, uncomp_tvb, + uncomp_offset, 1, ENC_BIG_ENDIAN); + + subencoding_type = tvb_get_guint8(uncomp_tvb, uncomp_offset); + palette_size = subencoding_type & 0x7F; + + uncomp_offset += 1; + + if(subencoding_type == 0) { /* Raw */ + length = width * height * bytes_per_cpixel; + VNC_BYTES_NEEDED(length); + + /* XXX - not working yet! */ + + proto_tree_add_item(zrle_subencoding_tree, + hf_vnc_zrle_raw, uncomp_tvb, + uncomp_offset, length, ENC_NA); + + } else if(subencoding_type >= 130 && subencoding_type <= 255) { + length = palette_size * bytes_per_cpixel; + VNC_BYTES_NEEDED(length); + + proto_tree_add_item(zrle_subencoding_tree, + hf_vnc_zrle_palette, uncomp_tvb, + uncomp_offset, length, ENC_NA); + + /* XXX - Not complete! */ + } + + } else { + proto_tree_add_expert(tree, pinfo, &ei_vnc_zrle_failed, tvb, *offset, data_len); + } +#endif /* HAVE_ZLIB */ + + *offset += data_len; + + return 0; /* bytes_needed */ +} + + +static guint +read_compact_len(tvbuff_t *tvb, gint *offset, gint *length, gint *value_length) +{ + gint b; + + VNC_BYTES_NEEDED(1); + + *value_length = 0; + + b = tvb_get_guint8(tvb, *offset); + *offset += 1; + *value_length += 1; + + *length = b & 0x7f; + if ((b & 0x80) != 0) { + VNC_BYTES_NEEDED(1); + + b = tvb_get_guint8(tvb, *offset); + *offset += 1; + *value_length += 1; + + *length |= (b & 0x7f) << 7; + + if ((b & 0x80) != 0) { + VNC_BYTES_NEEDED (1); + + b = tvb_get_guint8(tvb, *offset); + *offset += 1; + *value_length += 1; + + *length |= (b & 0xff) << 14; + } + } + + return 0; +} + + +static guint +process_compact_length_and_image_data(tvbuff_t *tvb, gint *offset, proto_tree *tree) +{ + guint bytes_needed; + guint length, value_length; + + bytes_needed = read_compact_len (tvb, offset, &length, &value_length); + if (bytes_needed != 0) + return bytes_needed; + + proto_tree_add_uint(tree, hf_vnc_tight_image_len, tvb, *offset - value_length, value_length, length); + + VNC_BYTES_NEEDED(length); + proto_tree_add_item(tree, hf_vnc_tight_image_data, tvb, *offset, length, ENC_NA); + *offset += length; + + return 0; /* bytes_needed */ +} + + +static guint +process_tight_rect_filter_palette(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, gint *bits_per_pixel) +{ + vnc_packet_t *per_packet_info; + gint num_colors; + guint palette_bytes; + + /* See TightVNC's vnc_unixsrc/vncviewer/tight.c:InitFilterPaletteBPP() */ + + per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); + /* Our calling function should have set the packet's proto data already */ + DISSECTOR_ASSERT(per_packet_info != NULL); + + VNC_BYTES_NEEDED(1); + proto_tree_add_item(tree, hf_vnc_tight_palette_num_colors, tvb, *offset, 1, ENC_BIG_ENDIAN); + num_colors = tvb_get_guint8(tvb, *offset); + *offset += 1; + + num_colors++; + if (num_colors < 2) + return 0; + + if (per_packet_info->depth == 24) + palette_bytes = num_colors * 3; + else + palette_bytes = num_colors * per_packet_info->depth / 8; + + VNC_BYTES_NEEDED(palette_bytes); + proto_tree_add_item(tree, hf_vnc_tight_palette_data, tvb, *offset, palette_bytes, ENC_NA); + *offset += palette_bytes; + + /* This is the number of bits per pixel *in the image data*, not the actual client depth */ + if (num_colors == 2) + *bits_per_pixel = 1; + else + *bits_per_pixel = 8; + + return 0; +} + +static guint +vnc_tight_encoding(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, const guint16 width _U_, const guint16 height _U_) +{ + vnc_packet_t *per_packet_info; + guint8 comp_ctl; + proto_item *compression_type_ti; + gint bit_offset; + gint bytes_needed = -1; + + per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); + /* Our calling function should have set the packet's proto data already */ + DISSECTOR_ASSERT(per_packet_info != NULL); + + /* See xserver/hw/vnc/rfbproto.h and grep for "Tight Encoding." for the following layout */ + + VNC_BYTES_NEEDED(1); + + /* least significant bits 0-3 are "reset compression stream N" */ + bit_offset = *offset * 8; + proto_tree_add_bits_item(tree, hf_vnc_tight_reset_stream0, tvb, bit_offset + 7, 1, ENC_BIG_ENDIAN); + proto_tree_add_bits_item(tree, hf_vnc_tight_reset_stream1, tvb, bit_offset + 6, 1, ENC_BIG_ENDIAN); + proto_tree_add_bits_item(tree, hf_vnc_tight_reset_stream2, tvb, bit_offset + 5, 1, ENC_BIG_ENDIAN); + proto_tree_add_bits_item(tree, hf_vnc_tight_reset_stream3, tvb, bit_offset + 4, 1, ENC_BIG_ENDIAN); + + /* most significant bits 4-7 are "compression type" */ + compression_type_ti = proto_tree_add_bits_item(tree, hf_vnc_tight_rect_type, tvb, bit_offset + 0, 4, ENC_BIG_ENDIAN); + + comp_ctl = tvb_get_guint8(tvb, *offset); + *offset += 1; + + comp_ctl >>= 4; /* skip over the "reset compression" bits from above */ + + /* compression format */ + + if (comp_ctl == TIGHT_RECT_FILL) { + /* "fill" encoding (solid rectangle) */ + + proto_item_append_text(compression_type_ti, " (fill encoding - solid rectangle)"); + + if (per_packet_info->depth == 24) { + VNC_BYTES_NEEDED(3); + proto_tree_add_item(tree, hf_vnc_tight_fill_color, tvb, *offset, 3, ENC_NA); + *offset += 3; + } else { + VNC_BYTES_NEEDED(per_packet_info->bytes_per_pixel); + proto_tree_add_item(tree, hf_vnc_tight_fill_color, tvb, *offset, per_packet_info->bytes_per_pixel, ENC_NA); + *offset += per_packet_info->bytes_per_pixel; + } + + bytes_needed = 0; + } else if (comp_ctl == TIGHT_RECT_JPEG) { + /* jpeg encoding */ + + proto_item_append_text(compression_type_ti, " (JPEG encoding)"); + bytes_needed = process_compact_length_and_image_data(tvb, offset, tree); + if (bytes_needed != 0) + return bytes_needed; + } else if (comp_ctl > TIGHT_RECT_MAX_VALUE) { + /* invalid encoding */ + + expert_add_info(pinfo, compression_type_ti, &ei_vnc_invalid_encoding); + } else { + guint row_size; + gint bits_per_pixel; + + /* basic encoding */ + + proto_item_append_text(compression_type_ti, " (basic encoding)"); + + proto_tree_add_bits_item(tree, hf_vnc_tight_filter_flag, tvb, bit_offset + 1, 1, ENC_BIG_ENDIAN); + + bits_per_pixel = per_packet_info->depth; + + if ((comp_ctl & TIGHT_RECT_EXPLICIT_FILTER_FLAG) != 0) { + guint8 filter_id; + + /* explicit filter */ + + VNC_BYTES_NEEDED(1); + proto_tree_add_item(tree, hf_vnc_tight_filter_id, tvb, *offset, 1, ENC_BIG_ENDIAN); + filter_id = tvb_get_guint8(tvb, *offset); + *offset += 1; + + switch (filter_id) { + case TIGHT_RECT_FILTER_COPY: + /* nothing to do */ + break; + + case TIGHT_RECT_FILTER_PALETTE: + bytes_needed = process_tight_rect_filter_palette(tvb, pinfo, offset, tree, &bits_per_pixel); + if (bytes_needed != 0) + return bytes_needed; + + break; + + case TIGHT_RECT_FILTER_GRADIENT: + /* nothing to do */ + break; + } + } else { + /* this is the same case as TIGHT_RECT_FILTER_COPY, so there's nothing special to do */ + } + + row_size = ((guint) width * bits_per_pixel + 7) / 8; + if (row_size * height < TIGHT_MIN_BYTES_TO_COMPRESS) { + guint num_bytes; + + /* The data is not compressed; just skip over it */ + + num_bytes = row_size * height; + VNC_BYTES_NEEDED(num_bytes); + proto_tree_add_item(tree, hf_vnc_tight_image_data, tvb, *offset, num_bytes, ENC_NA); + *offset += num_bytes; + + bytes_needed = 0; + } else { + /* The data is compressed; read its length and data */ + bytes_needed = process_compact_length_and_image_data(tvb, offset, tree); + if (bytes_needed != 0) + return bytes_needed; + } + } + + DISSECTOR_ASSERT(bytes_needed != -1); + + return bytes_needed; +} + + +static guint +decode_cursor(tvbuff_t *tvb, gint *offset, proto_tree *tree, + guint pixels_bytes, guint mask_bytes) +{ + guint total_bytes; + + total_bytes = pixels_bytes + mask_bytes; + VNC_BYTES_NEEDED (total_bytes); + + proto_tree_add_item(tree, hf_vnc_cursor_encoding_pixels, tvb, *offset, + pixels_bytes, ENC_NA); + *offset += pixels_bytes; + + proto_tree_add_item(tree, hf_vnc_cursor_encoding_bitmask, tvb, *offset, + mask_bytes, ENC_NA); + *offset += mask_bytes; + + return 0; /* bytes_needed */ +} + + +static guint +vnc_rich_cursor_encoding(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree, const guint16 width, const guint16 height) +{ + guint8 bytes_per_pixel = vnc_get_bytes_per_pixel(pinfo); + guint pixels_bytes, mask_bytes; + + pixels_bytes = width * height * bytes_per_pixel; + mask_bytes = ((width + 7) / 8) * height; + + return decode_cursor(tvb, offset, tree, + pixels_bytes, mask_bytes); +} + + +static guint +vnc_x_cursor_encoding(tvbuff_t *tvb, packet_info *pinfo _U_, gint *offset, + proto_tree *tree, const guint16 width, const guint16 height) +{ + gint bitmap_row_bytes = (width + 7) / 8; + gint mask_bytes = bitmap_row_bytes * height; + + VNC_BYTES_NEEDED (6); + proto_tree_add_item(tree, hf_vnc_cursor_x_fore_back, tvb, *offset, 6, ENC_NA); + *offset += 6; + + /* The length of the pixel data is the same as the length of the mask data (X cursors are strictly black/white) */ + return decode_cursor(tvb, offset, tree, + mask_bytes, mask_bytes); +} + + +static guint +vnc_server_set_colormap_entries(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree) +{ + guint16 number_of_colors; + guint counter, bytes_needed; + proto_item *ti; + proto_tree *vnc_colormap_num_groups, *vnc_colormap_color_group; + + col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Server set colormap entries"); + + number_of_colors = tvb_get_ntohs(tvb, 4); + + VNC_BYTES_NEEDED(3); + proto_tree_add_item(tree, hf_vnc_padding, tvb, *offset, 1, ENC_NA); + *offset += 1; /* Skip over 1 byte of padding */ + + proto_tree_add_item(tree, hf_vnc_colormap_first_color, + tvb, *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + /* XXX - this is 3 bytes into the tvb, but number_of_colors is set off + * of 4 bytes in... Bug??? + */ + ti = proto_tree_add_item(tree, hf_vnc_colormap_num_colors, tvb, + *offset, 2, ENC_BIG_ENDIAN); + + if (number_of_colors > 10000) { + expert_add_info_format(pinfo, ti, &ei_vnc_too_many_colors,"Too many colors (%d), aborting dissection", + number_of_colors); + return(0); + } + + bytes_needed = (number_of_colors * 6) + 5; + VNC_BYTES_NEEDED(bytes_needed); + + *offset += 2; + + ti = proto_tree_add_item(tree, hf_vnc_color_groups, tvb, + *offset, number_of_colors * 6, ENC_NA); + vnc_colormap_num_groups = + proto_item_add_subtree(ti, ett_vnc_colormap_num_groups); + + for(counter = 0; counter < number_of_colors; counter++) { + vnc_colormap_color_group = proto_tree_add_subtree_format(vnc_colormap_num_groups, tvb, + *offset, 6, ett_vnc_colormap_color_group, NULL, + "Color group #%d", counter+1); + + proto_tree_add_item(vnc_colormap_color_group, + hf_vnc_colormap_red, tvb, + *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(vnc_colormap_color_group, + hf_vnc_colormap_green, tvb, + *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + + proto_tree_add_item(vnc_colormap_color_group, + hf_vnc_colormap_blue, tvb, + *offset, 2, ENC_BIG_ENDIAN); + *offset += 2; + } + return 0; +} + + +static void +vnc_server_ring_bell(tvbuff_t *tvb _U_, packet_info *pinfo, gint *offset _U_, + proto_tree *tree _U_) +{ + col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Server ring bell on client"); + /* This message type has no payload... */ +} + + +static guint +vnc_server_cut_text(tvbuff_t *tvb, packet_info *pinfo, gint *offset, + proto_tree *tree) +{ + guint32 text_len; + proto_item *pi; + + col_append_sep_str(pinfo->cinfo, COL_INFO, "; ", "Server cut text"); + + text_len = tvb_get_ntohl(tvb, *offset); + pi = proto_tree_add_item(tree, hf_vnc_server_cut_text_len, tvb, *offset, 4, + ENC_BIG_ENDIAN); + *offset += 4; + + if (text_len > 100000) { + expert_add_info_format(pinfo, pi, &ei_vnc_too_many_cut_text, + "Too much cut text (%d), aborting dissection", text_len); + return(0); + } + + VNC_BYTES_NEEDED(text_len); + + proto_tree_add_item(tree, hf_vnc_server_cut_text, tvb, *offset, + text_len, ENC_ASCII); + *offset += text_len; + + return *offset; +} + + +static void +vnc_set_bytes_per_pixel(packet_info *pinfo, const guint8 bytes_per_pixel) +{ + vnc_packet_t *per_packet_info; + + per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); + /* Our calling function should have set the packet's proto data already */ + DISSECTOR_ASSERT(per_packet_info != NULL); + + per_packet_info->bytes_per_pixel = bytes_per_pixel; +} + + +static void +vnc_set_depth(packet_info *pinfo, const guint8 depth) +{ + vnc_packet_t *per_packet_info; + + per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); + /* Our calling function should have set the packet's proto data already */ + DISSECTOR_ASSERT(per_packet_info != NULL); + + per_packet_info->depth = depth; +} + + +static guint8 +vnc_get_bytes_per_pixel(packet_info *pinfo) +{ + vnc_packet_t *per_packet_info; + + per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); + /* Our calling function should have set the packet's proto data already */ + DISSECTOR_ASSERT(per_packet_info != NULL); + + return per_packet_info->bytes_per_pixel; +} + + +static guint8 +vnc_get_depth(packet_info *pinfo) +{ + vnc_packet_t *per_packet_info; + + per_packet_info = (vnc_packet_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_vnc, 0); + /* Our calling function should have set the packet's proto data already */ + DISSECTOR_ASSERT(per_packet_info != NULL); + + return per_packet_info->depth; +} + +/* Preference callbacks */ +static void +apply_vnc_prefs(void) { + vnc_tcp_range = prefs_get_range_value("vnc", "tcp.port"); +} + +/* Register the protocol with Wireshark */ +void +proto_register_vnc(void) +{ + module_t *vnc_module; /* To handle our preferences */ + expert_module_t* expert_vnc; + + /* Setup list of header fields */ + static hf_register_info hf[] = { + { &hf_vnc_padding, + { "Padding", "vnc.padding", + FT_NONE, BASE_NONE, NULL, 0x0, + "Unused space", HFILL } + }, + + { &hf_vnc_server_proto_ver, + { "Server protocol version", "vnc.server_proto_ver", + FT_STRING, BASE_NONE, NULL, 0x0, + "VNC protocol version on server", HFILL } + }, + { &hf_vnc_client_proto_ver, + { "Client protocol version", "vnc.client_proto_ver", + FT_STRING, BASE_NONE, NULL, 0x0, + "VNC protocol version on client", HFILL } + }, + { &hf_vnc_num_security_types, + { "Number of security types", "vnc.num_security_types", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of security (authentication) types supported by the server", HFILL } + }, + { &hf_vnc_security_type, + { "Security type", "vnc.security_type", + FT_UINT8, BASE_DEC, VALS(vnc_security_types_vs), 0x0, + "Security types offered by the server (VNC versions => 3.007)", HFILL } + }, + { &hf_vnc_server_security_type, + { "Security type", "vnc.server_security_type", + FT_UINT32, BASE_DEC, VALS(vnc_security_types_vs), 0x0, + "Security type mandated by the server", HFILL } + }, + { &hf_vnc_client_security_type, + { "Security type selected", "vnc.client_security_type", + FT_UINT8, BASE_DEC, VALS(vnc_security_types_vs), 0x0, + "Security type selected by the client", HFILL } + }, + { &hf_vnc_tight_num_tunnel_types, + { "Number of supported tunnel types", "vnc.num_tunnel_types", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Number of tunnel types for TightVNC", HFILL } + }, + { &hf_vnc_tight_tunnel_type_code, + { "Tunnel type code", "vnc.tunnel_type_code", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Tunnel type code specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_tunnel_type_vendor, + { "Tunnel type vendor", "vnc.tunnel_type_vendor", + FT_STRING, BASE_NONE, NULL, 0x0, + "Tunnel type vendor specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_tunnel_type_signature, + { "Tunnel type signature", "vnc.tunnel_type_signature", + FT_STRING, BASE_NONE, NULL, 0x0, + "Tunnel type signature specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_num_auth_types, + { "Number of supported authentication types", "vnc.num_auth_types", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Authentication types specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_auth_code, + { "Authentication code", "vnc.tight_auth_code", + FT_UINT32, BASE_DEC, VALS(vnc_security_types_vs), 0x0, + "Authentication code specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_server_message_type, + { "Server message type (TightVNC)", "vnc.tight_server_message_type", + FT_INT32, BASE_DEC, NULL, 0x0, + "Server message type specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_server_vendor, + { "Server vendor code", "vnc.server_vendor", + FT_STRING, BASE_NONE, NULL, 0x0, + "Server vendor code specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_signature, + { "Signature", "vnc.signature", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + { &hf_vnc_tight_server_name, + { "Server name", "vnc.server_name", + FT_STRING, BASE_NONE, NULL, 0x0, + "Server name specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_client_message_type, + { "Client message type (TightVNC)", "vnc.tight_client_message_type", + FT_INT32, BASE_DEC, NULL, 0x0, + "Client message type specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_client_vendor, + { "Client vendor code", "vnc.client_vendor", + FT_STRING, BASE_NONE, NULL, 0x0, + "Client vendor code specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_client_name, + { "Client name", "vnc.client_name", + FT_STRING, BASE_NONE, NULL, 0x0, + "Client name specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_encoding_type, + { "Encoding type", "vnc.encoding_type", + FT_INT32, BASE_DEC, VALS(encoding_types_vs), 0x0, + "Encoding type specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_encoding_vendor, + { "Encoding vendor code", "vnc.encoding_vendor", + FT_STRING, BASE_NONE, NULL, 0x0, + "Encoding vendor code specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_encoding_name, + { "Encoding name", "vnc.encoding_name", + FT_STRING, BASE_NONE, NULL, 0x0, + "Encoding name specific to TightVNC", HFILL } + }, + { &hf_vnc_tight_reset_stream0, + { "Reset compression stream 0", "vnc.tight_reset_stream0", + FT_BOOLEAN, BASE_NONE, NULL, 0x0, + "Tight compression, reset compression stream 0", HFILL } + }, + { &hf_vnc_tight_reset_stream1, + { "Reset compression stream 1", "vnc.tight_reset_stream1", + FT_BOOLEAN, BASE_NONE, NULL, 0x0, + "Tight compression, reset compression stream 1", HFILL } + }, + { &hf_vnc_tight_reset_stream2, + { "Reset compression stream 2", "vnc.tight_reset_stream2", + FT_BOOLEAN, BASE_NONE, NULL, 0x0, + "Tight compression, reset compression stream 2", HFILL } + }, + { &hf_vnc_tight_reset_stream3, + { "Reset compression stream 3", "vnc.tight_reset_stream3", + FT_BOOLEAN, BASE_NONE, NULL, 0x0, + "Tight compression, reset compression stream 3", HFILL } + }, + { &hf_vnc_tight_rect_type, + { "Rectangle type", "vnc.tight_rect_type", + FT_UINT8, BASE_HEX, NULL, 0x0, + "Tight compression, rectangle type", HFILL } + }, + { &hf_vnc_tight_image_len, + { "Image data length", "vnc.tight_image_len", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Tight compression, length of image data", HFILL } + }, + { &hf_vnc_tight_image_data, + { "Image data", "vnc.tight_image_data", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Tight compression, image data", HFILL } + }, + { &hf_vnc_tight_fill_color, + { "Fill color (RGB)", "vnc.tight_fill_color", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Tight compression, fill color for solid rectangle", HFILL } + }, + { &hf_vnc_tight_filter_flag, + { "Explicit filter flag", "vnc.tight_filter_flag", + FT_BOOLEAN, BASE_NONE, NULL, 0x0, + "Tight compression, explicit filter flag", HFILL } + }, + { &hf_vnc_tight_filter_id, + { "Filter ID", "vnc.tight_filter_id", + FT_UINT8, BASE_DEC, VALS(tight_filter_ids_vs), 0x0, + "Tight compression, filter ID", HFILL } + }, + { &hf_vnc_tight_palette_num_colors, + { "Number of colors in palette", "vnc.tight_palette_num_colors", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Tight compression, number of colors in rectangle's palette", HFILL } + }, + { &hf_vnc_tight_palette_data, + { "Palette data", "vnc.tight_palette_data", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Tight compression, palette data for a rectangle", HFILL } + }, + { &hf_vnc_auth_challenge, + { "Authentication challenge", "vnc.auth_challenge", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Random authentication challenge from server to client", HFILL } + }, + { &hf_vnc_auth_response, + { "Authentication response", "vnc.auth_response", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Client's encrypted response to the server's authentication challenge", HFILL } + }, + { &hf_vnc_auth_result, + { "Authentication result", "vnc.auth_result", + FT_BOOLEAN, 32, TFS(&auth_result_tfs), 0x1, + NULL, HFILL } + }, + { &hf_vnc_auth_error_length, + { "Length of authentication error", "vnc.auth_error_len", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Authentication error length (present only if the authentication result is fail)", HFILL } + }, + { &hf_vnc_auth_error, + { "Authentication error", "vnc.auth_error", + FT_STRING, BASE_NONE, NULL, 0x0, + "Authentication error (present only if the authentication result is fail)", HFILL } + }, + { &hf_vnc_ard_auth_generator, + { "Generator", "vnc.ard_auth_generator", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Generator for Diffie-Hellman key exchange", HFILL } + }, + { &hf_vnc_ard_auth_key_len, + { "Key length", "vnc.ard_auth_key_len", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Diffie-Hellman key length", HFILL } + }, + { &hf_vnc_ard_auth_modulus, + { "Prime modulus", "vnc.ard_auth_modulus", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Prime modulus for Diffie-Hellman key exchange", HFILL } + }, + { &hf_vnc_ard_auth_server_key, + { "Server public key", "vnc.ard_auth_server_key", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Server's public Diffie-Hellman key", HFILL } + }, + { &hf_vnc_ard_auth_credentials, + { "Encrypted credentials", "vnc.ard_auth_credentials", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Encrypted client username and password", HFILL } + }, + { &hf_vnc_ard_auth_client_key, + { "Client public key", "vnc.ard_auth_client_key", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Client's public Diffie-Hellman key", HFILL } + }, + { &hf_vnc_vencrypt_server_major_ver, + { "VeNCrypt server major version", "vnc.vencrypt_server_major_ver", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_vnc_vencrypt_server_minor_ver, + { "VeNCrypt server minor version", "vnc.vencrypt_server_minor_ver", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_vnc_vencrypt_client_major_ver, + { "VeNCrypt client major version", "vnc.vencrypt_client_major_ver", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_vnc_vencrypt_client_minor_ver, + { "VeNCrypt client minor version", "vnc.vencrypt_client_minor_ver", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_vnc_vencrypt_version_ack, + { "VeNCrypt version ack", "vnc.vencrypt_version_ack", + FT_BOOLEAN, 8, TFS(&tfs_error_ok), 0xFF, + NULL, HFILL } + }, + { &hf_vnc_vencrypt_auth_type, + { "VeNCrypt authentication type", "vnc.vencrypt_auth_type", + FT_UINT32, BASE_DEC, VALS(vnc_vencrypt_auth_types_vs), 0x0, + "Authentication type specific to VeNCrypt", HFILL } + }, + { &hf_vnc_vencrypt_num_auth_types, + { "VeNCrypt Number of supported authentication types", "vnc.vencrypt_num_auth_types", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_vnc_vencrypt_auth_type_ack, + { "VeNCrypt Authorization type ack", "vnc.vencrypt_auth_type_ack", + FT_BOOLEAN, 8, TFS(&tfs_ok_error), 0xFF, + NULL, HFILL } + }, + { &hf_vnc_share_desktop_flag, + { "Share desktop flag", "vnc.share_desktop_flag", + FT_BOOLEAN, BASE_NONE, NULL, 0x0, + "Client's desire to share the server's desktop with other clients", HFILL } + }, + { &hf_vnc_width, + { "Framebuffer width", "vnc.width", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Width of the framebuffer (screen) in pixels", HFILL } + }, + { &hf_vnc_height, + { "Framebuffer height", "vnc.height", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Height of the framebuffer (screen) in pixels", HFILL } + }, + { &hf_vnc_server_bits_per_pixel, + { "Bits per pixel", "vnc.server_bits_per_pixel", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of bits used by server for each pixel value on the wire from the server", HFILL } + }, + { &hf_vnc_server_depth, + { "Depth", "vnc.server_depth", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of useful bits in the pixel value on server", HFILL } + }, + { &hf_vnc_server_big_endian_flag, + { "Big endian flag", "vnc.server_big_endian_flag", + FT_BOOLEAN, BASE_NONE, NULL, 0x0, + "True if multi-byte pixels are interpreted as big endian by server", HFILL } + }, + { &hf_vnc_server_true_color_flag, + { "True color flag", "vnc.server_true_color_flag", + FT_BOOLEAN, BASE_NONE, NULL, 0x0, + "If true, then the next six items specify how to extract the red, green and blue intensities from the pixel value on the server.", HFILL } + }, + { &hf_vnc_server_red_max, + { "Red maximum", "vnc.server_red_max", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Maximum red value on server as n: 2^n - 1", HFILL } + }, + { &hf_vnc_server_green_max, + { "Green maximum", "vnc.server_green_max", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Maximum green value on server as n: 2^n - 1", HFILL } + }, + { &hf_vnc_server_blue_max, + { "Blue maximum", "vnc.server_blue_max", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Maximum blue value on server as n: 2^n - 1", HFILL } + }, + { &hf_vnc_server_red_shift, + { "Red shift", "vnc.server_red_shift", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of shifts needed to get the red value in a pixel to the least significant bit on the server", HFILL } + }, + { &hf_vnc_server_green_shift, + { "Green shift", "vnc.server_green_shift", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of shifts needed to get the green value in a pixel to the least significant bit on the server", HFILL } + }, + { &hf_vnc_server_blue_shift, + { "Blue shift", "vnc.server_blue_shift", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of shifts needed to get the blue value in a pixel to the least significant bit on the server", HFILL } + }, + { &hf_vnc_desktop_name_len, + { "Desktop name length", "vnc.desktop_name_len", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Length of desktop name in bytes", HFILL } + }, + { &hf_vnc_desktop_screen_num, + { "Number of screens", "vnc.screen_num", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_vnc_desktop_screen_id, + { "Screen ID", "vnc.screen_id", + FT_UINT32, BASE_DEC, NULL, 0x0, + "ID of screen", HFILL } + }, + { &hf_vnc_desktop_screen_x, + { "Screen X position", "vnc.screen_x", + FT_UINT16, BASE_DEC, NULL, 0x0, + "X coordinate of screen", HFILL } + }, + { &hf_vnc_desktop_screen_y, + { "Screen Y position", "vnc.screen_y", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Y coordinate of screen", HFILL } + }, + { &hf_vnc_desktop_screen_width, + { "Screen width", "vnc.screen_width", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Width of screen", HFILL } + }, + { &hf_vnc_desktop_screen_height, + { "Screen height", "vnc.screen_height", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Height of screen", HFILL } + }, + { &hf_vnc_desktop_screen_flags, + { "Screen flags", "vnc.screen_flags", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Flags of screen", HFILL } + }, + { &hf_vnc_desktop_name, + { "Desktop name", "vnc.desktop_name", + FT_STRING, BASE_NONE, NULL, 0x0, + "Name of the VNC desktop on the server", HFILL } + }, + { &hf_vnc_num_server_message_types, + { "Server message types", "vnc.num_server_message_types", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Unknown", HFILL } /* XXX - Needs description */ + }, + { &hf_vnc_num_client_message_types, + { "Client message types", "vnc.num_client_message_types", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Unknown", HFILL } /* XXX - Needs description */ + }, + { &hf_vnc_num_encoding_types, + { "Encoding types", "vnc.num_encoding_types", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Unknown", HFILL } /* XXX - Needs description */ + }, + { &hf_vnc_client_message_type, + { "Client Message Type", "vnc.client_message_type", + FT_UINT8, BASE_DEC, VALS(vnc_client_message_types_vs), 0x0, + "Message type from client", HFILL } + }, + { &hf_vnc_client_bits_per_pixel, + { "Bits per pixel", "vnc.client_bits_per_pixel", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of bits used by server for each pixel value on the wire from the client", HFILL } + }, + { &hf_vnc_client_depth, + { "Depth", "vnc.client_depth", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of useful bits in the pixel value on client", HFILL } + }, + { &hf_vnc_client_big_endian_flag, + { "Big endian flag", "vnc.client_big_endian_flag", + FT_BOOLEAN, BASE_NONE, NULL, 0x0, + "True if multi-byte pixels are interpreted as big endian by client", HFILL } + }, + { &hf_vnc_client_true_color_flag, + { "True color flag", "vnc.client_true_color_flag", + FT_BOOLEAN, BASE_NONE, NULL, 0x0, + "If true, then the next six items specify how to extract the red, green and blue intensities from the pixel value on the client.", HFILL } + }, + { &hf_vnc_client_red_max, + { "Red maximum", "vnc.client_red_max", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Maximum red value on client as n: 2^n - 1", HFILL } + }, + { &hf_vnc_client_green_max, + { "Green maximum", "vnc.client_green_max", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Maximum green value on client as n: 2^n - 1", HFILL } + }, + { &hf_vnc_client_blue_max, + { "Blue maximum", "vnc.client_blue_max", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Maximum blue value on client as n: 2^n - 1", HFILL } + }, + { &hf_vnc_client_red_shift, + { "Red shift", "vnc.client_red_shift", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of shifts needed to get the red value in a pixel to the least significant bit on the client", HFILL } + }, + { &hf_vnc_client_green_shift, + { "Green shift", "vnc.client_green_shift", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of shifts needed to get the green value in a pixel to the least significant bit on the client", HFILL } + }, + { &hf_vnc_client_blue_shift, + { "Blue shift", "vnc.client_blue_shift", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of shifts needed to get the blue value in a pixel to the least significant bit on the client", HFILL } + }, + + /* Client Key Event */ + { &hf_vnc_key_down, + { "Key down", "vnc.key_down", + FT_BOOLEAN, BASE_NONE, TFS(&tfs_yes_no), 0x0, + "Specifies whether the key is being pressed or not", HFILL } + }, + { &hf_vnc_key, + { "Key", "vnc.key", + FT_UINT32, BASE_HEX | BASE_EXT_STRING, &x11_keysym_vals_source_ext, 0x0, /* keysym_vals_source_exr is from packet-x11.c */ + "Key being pressed/depressed", HFILL } + }, + + /* Client Pointer Event */ + { &hf_vnc_button_1_pos, + { "Mouse button #1 position", "vnc.button_1_pos", + FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x1, + "Whether mouse button #1 is being pressed or not", HFILL } + }, + { &hf_vnc_button_2_pos, + { "Mouse button #2 position", "vnc.button_2_pos", + FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x2, + "Whether mouse button #2 is being pressed or not", HFILL } + }, + { &hf_vnc_button_3_pos, + { "Mouse button #3 position", "vnc.button_3_pos", + FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x4, + "Whether mouse button #3 is being pressed or not", HFILL } + }, + { &hf_vnc_button_4_pos, + { "Mouse button #4 position", "vnc.button_4_pos", + FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x8, + "Whether mouse button #4 is being pressed or not", HFILL } + }, + { &hf_vnc_button_5_pos, + { "Mouse button #5 position", "vnc.button_5_pos", + FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x10, + "Whether mouse button #5 is being pressed or not", HFILL } + }, + { &hf_vnc_button_6_pos, + { "Mouse button #6 position", "vnc.button_6_pos", + FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x20, + "Whether mouse button #6 is being pressed or not", HFILL } + }, + { &hf_vnc_button_7_pos, + { "Mouse button #7 position", "vnc.button_7_pos", + FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x40, + "Whether mouse button #7 is being pressed or not", HFILL } + }, + { &hf_vnc_button_8_pos, + { "Mouse button #8 position", "vnc.button_8_pos", + FT_BOOLEAN, 8, TFS(&tfs_pressed_not_pressed), 0x80, + "Whether mouse button #8 is being pressed or not", HFILL } + }, + { &hf_vnc_pointer_x_pos, + { "X position", "vnc.pointer_x_pos", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Position of mouse cursor on the x-axis", HFILL } + }, + { &hf_vnc_pointer_y_pos, + { "Y position", "vnc.pointer_y_pos", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Position of mouse cursor on the y-axis", HFILL } + }, + { &hf_vnc_encoding_num, + { "Number of encodings", "vnc.client_set_encodings_num", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Number of encodings used to send pixel data from server to client", HFILL } + }, + { &hf_vnc_client_set_encodings_encoding_type, + { "Encoding type", "vnc.client_set_encodings_encoding_type", + FT_INT32, BASE_DEC, VALS(encoding_types_vs), 0x0, + "Type of encoding used to send pixel data from server to client", HFILL } + }, + + /* Client Framebuffer Update Request */ + { &hf_vnc_update_req_incremental, + { "Incremental update", "vnc.update_req_incremental", + FT_BOOLEAN, BASE_NONE, NULL, 0x0, + "Specifies if the client wants an incremental update instead of a full one", HFILL } + }, + { &hf_vnc_update_req_x_pos, + { "X position", "vnc.update_req_x_pos", + FT_UINT16, BASE_DEC, NULL, 0x0, + "X position of framebuffer (screen) update requested", HFILL } + }, + { &hf_vnc_update_req_y_pos, + { "Y position", "vnc.update_req_y_pos", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Y position of framebuffer (screen) update request", HFILL } + }, + { &hf_vnc_update_req_width, + { "Width", "vnc.update_req_width", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Width of framebuffer (screen) update request", HFILL } + }, + { &hf_vnc_update_req_height, + { "Height", "vnc.update_req_height", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Height of framebuffer (screen) update request", HFILL } + }, + { &hf_vnc_client_cut_text_len, + { "Length", "vnc.client_cut_text_len", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Length of client's copy/cut text (clipboard) string in bytes", HFILL } + }, + { &hf_vnc_client_cut_text, + { "Text", "vnc.client_cut_text", + FT_STRING, BASE_NONE, NULL, 0x0, + "Text string in the client's copy/cut text (clipboard)", HFILL } + }, + + + /********** Server Message Types **********/ + { &hf_vnc_server_message_type, + { "Server Message Type", "vnc.server_message_type", + FT_UINT8, BASE_DEC, VALS(vnc_server_message_types_vs), 0x0, + "Message type from server", HFILL } + }, + + { &hf_vnc_rectangle_num, + { "Number of rectangles", "vnc.fb_update_num_rects", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Number of rectangles of this server framebuffer update", HFILL } + }, + + { &hf_vnc_fb_update_x_pos, + { "X position", "vnc.fb_update_x_pos", + FT_UINT16, BASE_DEC, NULL, 0x0, + "X position of this server framebuffer update", HFILL } + }, + + { &hf_vnc_fb_update_y_pos, + { "Y position", "vnc.fb_update_y_pos", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Y position of this server framebuffer update", HFILL } + }, + + { &hf_vnc_fb_update_width, + { "Width", "vnc.fb_update_width", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Width of this server framebuffer update", HFILL } + }, + + { &hf_vnc_fb_update_height, + { "Height", "vnc.fb_update_height", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Height of this server framebuffer update", HFILL } + }, + + { &hf_vnc_fb_update_encoding_type, + { "Encoding type", "vnc.fb_update_encoding_type", + FT_INT32, BASE_DEC, VALS(encoding_types_vs), 0x0, + "Encoding type of this server framebuffer update", HFILL } + }, + + /* Cursor encoding */ + { &hf_vnc_cursor_x_fore_back, + { "X Cursor foreground RGB / background RGB", "vnc.cursor_x_fore_back", + FT_BYTES, BASE_NONE, NULL, 0x0, + "RGB values for the X cursor's foreground and background", HFILL } + }, + + { &hf_vnc_cursor_encoding_pixels, + { "Cursor encoding pixels", "vnc.cursor_encoding_pixels", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Cursor encoding pixel data", HFILL } + }, + + { &hf_vnc_cursor_encoding_bitmask, + { "Cursor encoding bitmask", "vnc.cursor_encoding_bitmask", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Cursor encoding pixel bitmask", HFILL } + }, + + /* Raw Encoding */ + { &hf_vnc_raw_pixel_data, + { "Pixel data", "vnc.raw_pixel_data", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Raw pixel data.", HFILL } + }, + + /* CopyRect Encoding*/ + { &hf_vnc_copyrect_src_x_pos, + { "Source x position", "vnc.copyrect_src_x_pos", + FT_UINT16, BASE_DEC, NULL, 0x0, + "X position of the rectangle to copy from", HFILL } + }, + + { &hf_vnc_copyrect_src_y_pos, + { "Source y position", "vnc.copyrect_src_y_pos", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Y position of the rectangle to copy from", HFILL } + }, + + /* RRE Encoding */ + { &hf_vnc_rre_num_subrects, + { "Number of subrectangles", "vnc.rre_num_subrects", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Number of subrectangles contained in this encoding type", HFILL } + }, + + { &hf_vnc_rre_bg_pixel, + { "Background pixel value", "vnc.rre_bg_pixel", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + + { &hf_vnc_rre_subrect_pixel, + { "Pixel value", "vnc.rre_subrect_pixel", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Subrectangle pixel value", HFILL } + }, + + { &hf_vnc_rre_subrect_x_pos, + { "X position", "vnc.rre_subrect_x_pos", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Position of this subrectangle on the x axis", HFILL } + }, + + { &hf_vnc_rre_subrect_y_pos, + { "Y position", "vnc.rre_subrect_y_pos", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Position of this subrectangle on the y axis", HFILL } + }, + + { &hf_vnc_rre_subrect_width, + { "Width", "vnc.rre_subrect_width", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Width of this subrectangle", HFILL } + }, + + { &hf_vnc_rre_subrect_height, + { "Height", "vnc.rre_subrect_height", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Height of this subrectangle", HFILL } + }, + + + /* Hextile Encoding */ + { &hf_vnc_hextile_subencoding_mask, + { "Subencoding type", "vnc.hextile_subencoding", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Hextile subencoding type.", HFILL } + }, + + { &hf_vnc_hextile_raw, + { "Raw", "vnc.hextile_raw", + FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x1, + "Raw subencoding is used in this tile", HFILL } + }, + + { &hf_vnc_hextile_raw_value, + { "Raw pixel values", "vnc.hextile_raw_value", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Raw subencoding pixel values", HFILL } + }, + + { &hf_vnc_hextile_bg, + { "Background Specified", "vnc.hextile_bg", + FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x2, + "Background Specified subencoding is used in this tile", HFILL } + }, + + { &hf_vnc_hextile_bg_value, + { "Background pixel value", "vnc.hextile_bg_value", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Background color for this tile", HFILL } + }, + + { &hf_vnc_hextile_fg, + { "Foreground Specified", "vnc.hextile_fg", + FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x4, + "Foreground Specified subencoding is used in this tile", HFILL } + }, + + { &hf_vnc_hextile_fg_value, + { "Foreground pixel value", "vnc.hextile_fg_value", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Foreground color for this tile", HFILL } + }, + + { &hf_vnc_hextile_anysubrects, + { "Any Subrects", "vnc.hextile_anysubrects", + FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x8, + "Any subrects subencoding is used in this tile", HFILL } + }, + + { &hf_vnc_hextile_num_subrects, + { "Number of subrectangles", "vnc.hextile_num_subrects", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of subrectangles that follow", HFILL } + }, + + { &hf_vnc_hextile_subrectscolored, + { "Subrects Colored", "vnc.hextile_subrectscolored", + FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x10, + "Subrects colored subencoding is used in this tile", HFILL } + }, + + { &hf_vnc_hextile_subrect_pixel_value, + { "Pixel value", "vnc.hextile_subrect_pixel_value", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Pixel value of this subrectangle", HFILL } + }, + + { &hf_vnc_hextile_subrect_x_pos, + { "X position", "vnc.hextile_subrect_x_pos", + FT_UINT8, BASE_DEC, NULL, 0xF0, /* Top 4 bits */ + "X position of this subrectangle", HFILL } + }, + + { &hf_vnc_hextile_subrect_y_pos, + { "Y position", "vnc.hextile_subrect_y_pos", + FT_UINT8, BASE_DEC, NULL, 0xF, /* Bottom 4 bits */ + "Y position of this subrectangle", HFILL } + }, + + { &hf_vnc_hextile_subrect_width, + { "Width", "vnc.hextile_subrect_width", + FT_UINT8, BASE_DEC, NULL, 0xF0, /* Top 4 bits */ + "Subrectangle width minus one", HFILL } + }, + + { &hf_vnc_hextile_subrect_height, + { "Height", "vnc.hextile_subrect_height", + FT_UINT8, BASE_DEC, NULL, 0xF, /* Bottom 4 bits */ + "Subrectangle height minus one", HFILL } + }, + + + /* ZRLE Encoding */ + { &hf_vnc_zrle_len, + { "ZRLE compressed length", "vnc.zrle_len", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Length of compressed ZRLE data that follows", HFILL } + }, + + { &hf_vnc_zrle_subencoding, + { "Subencoding type", "vnc.zrle_subencoding", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Subencoding type byte", HFILL } + }, + + { &hf_vnc_zrle_rle, + { "RLE", "vnc.zrle_rle", + FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x80, /* Upper bit */ + "Specifies that data is run-length encoded", HFILL } + }, + + { &hf_vnc_zrle_palette_size, + { "Palette size", "vnc.zrle_palette_size", + FT_UINT8, BASE_DEC, NULL, 0x7F, /* Lower 7 bits */ + NULL, HFILL } + }, + + { &hf_vnc_zrle_data, + { "ZRLE compressed data", "vnc.zrle_data", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Compressed ZRLE data. Compiling with zlib support will uncompress and dissect this data", HFILL } + }, + + { &hf_vnc_zrle_raw, + { "Pixel values", "vnc.zrle_raw", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Raw pixel values for this tile", HFILL } + }, + + { &hf_vnc_zrle_palette, + { "Palette", "vnc.zrle_palette", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Palette pixel values", HFILL } + }, + + /* Server Set Colormap Entries */ + { &hf_vnc_colormap_first_color, + { "First color", "vnc.colormap_first_color", + FT_UINT16, BASE_DEC, NULL, 0x0, + "First color that should be mapped to given RGB intensities", HFILL } + }, + + { &hf_vnc_color_groups, + { "Color groups", "vnc.color_groups", + FT_NONE, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + + { &hf_vnc_colormap_num_colors, + { "Number of color groups", "vnc.colormap_groups", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Number of red/green/blue color groups", HFILL } + }, + { &hf_vnc_colormap_red, + { "Red", "vnc.colormap_red", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Red intensity", HFILL } + }, + { &hf_vnc_colormap_green, + { "Green", "vnc.colormap_green", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Green intensity", HFILL } + }, + { &hf_vnc_colormap_blue, + { "Blue", "vnc.colormap_blue", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Blue intensity", HFILL } + }, + + /* Server Cut Text */ + { &hf_vnc_server_cut_text_len, + { "Length", "vnc.server_cut_text_len", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Length of server's copy/cut text (clipboard) string in bytes", HFILL } + }, + { &hf_vnc_server_cut_text, + { "Text", "vnc.server_cut_text", + FT_STRING, BASE_NONE, NULL, 0x0, + "Text string in the server's copy/cut text (clipboard)", HFILL } + }, + + /* LibVNCServer additions */ + { &hf_vnc_supported_messages_client2server, + { "Client2server", "vnc.supported_messages_client2server", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Supported client to server messages (bit flags)", HFILL } + }, + { &hf_vnc_supported_messages_server2client, + { "Server2client", "vnc.supported_messages_server2client", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Supported server to client messages (bit flags)", HFILL } + }, + { &hf_vnc_num_supported_encodings, + { "Number of supported encodings", "vnc.num_supported_encodings", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_vnc_supported_encodings, + { "Encoding", "vnc.supported_encodings", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Supported encoding", HFILL } + }, + { &hf_vnc_server_identity, + { "Server Identity", "vnc.server_identity", + FT_STRING, BASE_NONE, NULL, 0x0, + "Server identity string", HFILL } + }, + + /* MirrorLink */ + { &hf_vnc_mirrorlink_type, + { "Type", "vnc.mirrorlink_type", + FT_UINT8, BASE_DEC, VALS(vnc_mirrorlink_types_vs), 0x0, + "MirrorLink extension message type", HFILL } + }, + { &hf_vnc_mirrorlink_length, + { "Length", "vnc.mirrorlink_length", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Payload length", HFILL } + }, + { &hf_vnc_mirrorlink_version_major, + { "Major Version", "vnc.mirrorlink_version_major", + FT_UINT8, BASE_DEC, NULL, 0x0, + "MirrorLink major version", HFILL } + }, + { &hf_vnc_mirrorlink_version_minor, + { "Minor Version", "vnc.mirrorlink_version_minor", + FT_UINT8, BASE_DEC, NULL, 0x0, + "MirrorLink minor version", HFILL } + }, + { &hf_vnc_mirrorlink_framebuffer_configuration, + { "Configuration", + "vnc.mirrorlink_framebuffer_configuration", + FT_UINT16, BASE_HEX, NULL, 0x0, + "Framebuffer configuration", HFILL } + }, + { &hf_vnc_mirrorlink_pixel_width, + { "Pixel Width", "vnc.mirrorlink_pixel_width", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Display width [pixel]", HFILL } + }, + { &hf_vnc_mirrorlink_pixel_height, + { "Pixel Height", "vnc.mirrorlink_pixel_height", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Display height [pixel]", HFILL } + }, + { &hf_vnc_mirrorlink_pixel_format, + { "Pixel Format", "vnc.mirrorlink_pixel_format", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Pixel format support", HFILL } + }, + { &hf_vnc_mirrorlink_display_width, + { "Display Width", "vnc.mirrorlink_display_width", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Display width [mm]", HFILL } + }, + { &hf_vnc_mirrorlink_display_height, + { "Display Height", "vnc.mirrorlink_display_height", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Display height [mm]", HFILL } + }, + { &hf_vnc_mirrorlink_display_distance, + { "Display Distance", "vnc.mirrorlink_display_distance", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Display distance [mm]", HFILL } + }, + { &hf_vnc_mirrorlink_keyboard_language, + { "Keyboard Language", "vnc.mirrorlink_keyboard_language", + FT_STRING, BASE_NONE, NULL, 0x0, + "Keyboard layout - Language code (according ISO 639-1)", + HFILL } + }, + { &hf_vnc_mirrorlink_keyboard_country, + { "Keyboard Country", "vnc.mirrorlink_keyboard_country", + FT_STRING, BASE_NONE, NULL, 0x0, + "Keyboard layout - Country code (according ISO 3166-1 alpha-2)", + HFILL } + }, + { &hf_vnc_mirrorlink_ui_language, + { "UI Language", "vnc.mirrorlink_ui_language", + FT_STRING, BASE_NONE, NULL, 0x0, + "UI language - Language code (according ISO 639-1)", HFILL } + }, + { &hf_vnc_mirrorlink_ui_country, + { "UI Country", "vnc.mirrorlink_ui_country", + FT_STRING, BASE_NONE, NULL, 0x0, + "UI language - Country code (according ISO 3166-1 alpha 2)", + HFILL } + }, + { &hf_vnc_mirrorlink_knob_keys, + { "Knob Keys", "vnc.mirrorlink_knob_keys", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Supported knob keys", HFILL } + }, + { &hf_vnc_mirrorlink_device_keys, + { "Device Keys", "vnc.mirrorlink_device_keys", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Supported device keys", HFILL } + }, + { &hf_vnc_mirrorlink_multimedia_keys, + { "Multimedia Keys", "vnc.mirrorlink_multimedia_keys", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Supported multimedia keys", HFILL } + }, + { &hf_vnc_mirrorlink_key_related, + { "Keyboard", "vnc.mirrorlink_key_related", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Keyboard related", HFILL } + }, + { &hf_vnc_mirrorlink_pointer_related, + { "Pointer", "vnc.mirrorlink_pointer_related", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Pointer related", HFILL } + }, + { &hf_vnc_mirrorlink_key_symbol_value_client, + { "Client KeySymValue", + "vnc.mirrorlink_key_symbol_value_client", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Client key symbol value", HFILL } + }, + { &hf_vnc_mirrorlink_key_symbol_value_server, + { "Server KeySymValue", + "vnc.mirrorlink_key_symbol_value_server", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Server key symbol value", HFILL } + }, + { &hf_vnc_mirrorlink_key_configuration, + { "Configuration", "vnc.mirrorlink_key_configuration", + FT_UINT8, BASE_HEX, NULL, 0x0, + "Key event listing configuration", HFILL } + }, + { &hf_vnc_mirrorlink_key_num_events, + { "Number of Key Events", "vnc.mirrorlink_key_num_events", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of key events in list", HFILL } + }, + { &hf_vnc_mirrorlink_key_event_counter, + { "Key Event Counter", "vnc.mirrorlink_key_event_counter", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Key event listing counter", HFILL } + }, + { &hf_vnc_mirrorlink_key_symbol_value, + { "KeySymValue", + "vnc.mirrorlink_key_symbol_value", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Key symbol value", HFILL } + }, + { &hf_vnc_mirrorlink_key_request_configuration, + { "Configuration", "vnc.mirrorlink_key_request_configuration", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Key event listing request configuration", HFILL } + }, + { &hf_vnc_mirrorlink_keyboard_configuration, + { "Configuration", "vnc.mirrorlink_keyboard_configuration", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Virtual keyboard configuration", HFILL } + }, + { &hf_vnc_mirrorlink_cursor_x, + { "Cursor X", "vnc.mirrorlink_cursor_x", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Cursor - X position", HFILL } + }, + { &hf_vnc_mirrorlink_cursor_y, + { "Cursor Y", "vnc.mirrorlink_cursor_y", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Cursor - Y position", HFILL } + }, + { &hf_vnc_mirrorlink_text_x, + { "Text X", "vnc.mirrorlink_text_x", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Text input area - X position", HFILL } + }, + { &hf_vnc_mirrorlink_text_y, + { "Text Y", "vnc.mirrorlink_text_y", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Text input area - Y position", HFILL } + }, + { &hf_vnc_mirrorlink_text_width, + { "Text Width", "vnc.mirrorlink_text_width", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Text input area - Width", HFILL } + }, + { &hf_vnc_mirrorlink_text_height, + { "Text Height", "vnc.mirrorlink_text_height", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Text input area - Height", HFILL } + }, + { &hf_vnc_mirrorlink_keyboard_request_configuration, + { "Configuration", + "vnc.mirrorlink_keyboard_request_configuration", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Virtual keyboard request configuration", HFILL } + }, + { &hf_vnc_mirrorlink_device_status, + { "Device Status", "vnc.mirrorlink_device_status", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Status of Device Features", HFILL } + }, + { &hf_vnc_mirrorlink_app_id, + { "App Id", "vnc.mirrorlink_app_id", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Unique application id", HFILL } + }, + { &hf_vnc_mirrorlink_fb_block_x, + { "Frambuffer X", "vnc.mirrorlink_fb_block_x", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Frambuffer blocking - X position", HFILL } + }, + { &hf_vnc_mirrorlink_fb_block_y, + { "Frambuffer Y", "vnc.mirrorlink_fb_block_y", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Frambuffer blocking - Y position", HFILL } + }, + { &hf_vnc_mirrorlink_fb_block_width, + { "Frambuffer Width", "vnc.mirrorlink_fb_block_width", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Frambuffer blocking - Width", HFILL } + }, + { &hf_vnc_mirrorlink_fb_block_height, + { "Frambuffer Height", "vnc.mirrorlink_fb_block_height", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Frambuffer blocking - Height", HFILL } + }, + { &hf_vnc_mirrorlink_fb_block_reason, + { "Reason", "vnc.mirrorlink_fb_block_reason", + FT_UINT16, BASE_HEX, NULL, 0x0, + "Reason for blocking", HFILL } + }, + { &hf_vnc_mirrorlink_audio_block_reason, + { "Reason", "vnc.mirrorlink_audio_block_reason", + FT_UINT16, BASE_HEX, NULL, 0x0, + "Reason for blocking", HFILL } + }, + { &hf_vnc_mirrorlink_touch_num_events, + { "Number of Touch Events", "vnc.mirrorlink_touch_num_events", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Number of touch events in list", HFILL } + }, + { &hf_vnc_mirrorlink_touch_x, + { "Touch X", "vnc.mirrorlink_touch_x", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Touch event - X position", HFILL } + }, + { &hf_vnc_mirrorlink_touch_y, + { "Touch Y", "vnc.mirrorlink_touch_y", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Touch event - Y position", HFILL } + }, + { &hf_vnc_mirrorlink_touch_id, + { "Touch Id", "vnc.mirrorlink_touch_id", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Touch event - identifier", HFILL } + }, + { &hf_vnc_mirrorlink_touch_pressure, + { "Touch Pressure", "vnc.mirrorlink_touch_pressure", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Touch event - pressure value", HFILL } + }, + { &hf_vnc_mirrorlink_text, + { "Text", "vnc.mirrorlink_text", + FT_STRING, BASE_NONE, NULL, 0x0, + "Textual information", HFILL } + }, + { &hf_vnc_mirrorlink_text_length, + { "Length", "vnc.mirrorlink_text_length", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Length of textual information", HFILL } + }, + { &hf_vnc_mirrorlink_text_max_length, + { "Max Length", "vnc.mirrorlink_text_max_length", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Maximum length of textual information", HFILL } + }, + { &hf_vnc_mirrorlink_unknown, + { "Unknown", "vnc.mirrorlink_unknown", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Unknown data", HFILL } + }, + + /* Fence */ + { &hf_vnc_fence_flags, + {"Fence flags", "vnc.fence_flags", FT_UINT32, BASE_HEX, + NULL, 0, NULL, HFILL}}, + + { &hf_vnc_fence_request, + { "Fence_request", "vnc.fence_request", + FT_BOOLEAN, 32, NULL, VNC_FENCE_REQUEST, + NULL, HFILL } + }, + { &hf_vnc_fence_sync_next, + { "Fence_sync_next", "vnc.fence_sync_next", + FT_BOOLEAN, 32, NULL, VNC_FENCE_SYNC_NEXT, + NULL, HFILL } + }, + { &hf_vnc_fence_block_after, + { "Fence_block_after", "vnc.fence_block_after", + FT_BOOLEAN, 32, NULL, VNC_FENCE_BLOCK_AFTER, + NULL, HFILL } + }, + { &hf_vnc_fence_block_before, + { "Fence block_before", "vnc.fence_block_before", + FT_BOOLEAN, 32, NULL, VNC_FENCE_BLOCK_BEFORE, + NULL, HFILL } + }, + { &hf_vnc_fence_payload_length, + { "Fence payload length", "vnc.fence_payload_length", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_vnc_fence_payload, + { "Fence payload", "vnc.fence_payload", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + + /* Context Information */ + { &hf_vnc_context_information_app_id, + { "App Id", "vnc.context_information_app_id", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Unique application id", HFILL } + }, + { &hf_vnc_context_information_app_trust_level, + { "App Trust Level", + "vnc.context_information_app_trust_level", + FT_UINT16, BASE_HEX, NULL, 0x0, + "Trust Level for Application Category", HFILL } + }, + { &hf_vnc_context_information_content_trust_level, + { "Content Trust Level", + "vnc.context_information_content_trust_level", + FT_UINT16, BASE_HEX, NULL, 0x0, + "Trust Level for Content Category", HFILL } + }, + { &hf_vnc_context_information_app_category, + { "App Category", "vnc.context_information_app_category", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Application Category", HFILL } + }, + { &hf_vnc_context_information_content_category, + { "Content Category", + "vnc.context_information_content_category", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Visual content category", HFILL } + }, + { &hf_vnc_context_information_content_rules, + { "Content Rules", "vnc.context_information_content_rules", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Visual content rules", HFILL } + }, + + /* Scan Line based Run-Length Encoding */ + { &hf_vnc_slrle_run_num, + { "Number of Runs", "vnc.slrle_run_num", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Number of Runs within Line", HFILL } + }, + { &hf_vnc_slrle_run_data, + { "Raw RLE data", "vnc.slrle_run_data", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Raw Run-Length encoded data within Line", HFILL } + }, + + /* H.264 Encoding */ + { &hf_vnc_h264_slice_type, + { "Slice Type", "vnc.h264_slice_type", + FT_UINT32, BASE_DEC, VALS(vnc_h264_slice_types_vs), 0x0, + "Frame slice type", HFILL } + }, + { &hf_vnc_h264_nbytes, + { "Number of Bytes", "vnc.h264_nbytes", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Number of bytes within frame", HFILL } + }, + { &hf_vnc_h264_width, + { "Width", "vnc.h264_width", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Frame Width", HFILL } + }, + { &hf_vnc_h264_height, + { "Height", "vnc.h264_height", + FT_UINT32, BASE_DEC, NULL, 0x0, + "Frame Height", HFILL } + }, + { &hf_vnc_h264_data, + { "Data", "vnc.h264_data", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Frame H.264 data", HFILL } + }, + + }; + + /* Setup protocol subtree arrays */ + static gint *ett[] = { + &ett_vnc, + &ett_vnc_client_message_type, + &ett_vnc_server_message_type, + &ett_vnc_rect, + &ett_vnc_encoding_type, + &ett_vnc_rre_subrect, + &ett_vnc_hextile_subencoding_mask, + &ett_vnc_hextile_num_subrects, + &ett_vnc_hextile_subrect, + &ett_vnc_hextile_tile, + &ett_vnc_zrle_subencoding, + &ett_vnc_colormap_num_groups, + &ett_vnc_desktop_screen, + &ett_vnc_colormap_color_group, + &ett_vnc_key_events, + &ett_vnc_touch_events, + &ett_vnc_slrle_subline, + &ett_vnc_fence_flags + }; + + static ei_register_info ei[] = { + { &ei_vnc_possible_gtk_vnc_bug, { "vnc.possible_gtk_vnc_bug", PI_MALFORMED, PI_ERROR, "NULL found in greeting. client -> server greeting must be 12 bytes (possible gtk-vnc bug)", EXPFILL }}, + { &ei_vnc_auth_code_mismatch, { "vnc.auth_code_mismatch", PI_PROTOCOL, PI_WARN, "Authentication code does not match vendor or signature", EXPFILL }}, + { &ei_vnc_unknown_tight_vnc_auth, { "vnc.unknown_tight_vnc_auth", PI_PROTOCOL, PI_ERROR, "Unknown TIGHT VNC authentication", EXPFILL }}, + { &ei_vnc_too_many_rectangles, { "vnc.too_many_rectangles", PI_MALFORMED, PI_ERROR, "Too many rectangles, aborting dissection", EXPFILL }}, + { &ei_vnc_too_many_sub_rectangles, { "vnc.too_many_sub_rectangles", PI_MALFORMED, PI_ERROR, "Too many sub-rectangles, aborting dissection", EXPFILL }}, + { &ei_vnc_invalid_encoding, { "vnc.invalid_encoding", PI_MALFORMED, PI_ERROR, "Invalid encoding", EXPFILL }}, + { &ei_vnc_too_many_colors, { "vnc.too_many_colors", PI_MALFORMED, PI_ERROR, "Too many colors, aborting dissection", EXPFILL }}, + { &ei_vnc_too_many_cut_text, { "vnc.too_many_cut_text", PI_MALFORMED, PI_ERROR, "Too much cut text, aborting dissection", EXPFILL }}, + { &ei_vnc_zrle_failed, { "vnc.zrle_failed", PI_UNDECODED, PI_ERROR, "Decompression of ZRLE data failed", EXPFILL }}, + { &ei_vnc_unknown_tight, { "vnc.unknown_tight_packet", PI_UNDECODED, PI_WARN, "Unknown packet (TightVNC)", EXPFILL }}, + { &ei_vnc_reassemble, { "vnc.reassemble", PI_REASSEMBLE, PI_CHAT, "See further on for dissection of the complete (reassembled) PDU", EXPFILL }}, + }; + + /* Register the protocol name and description */ + proto_vnc = proto_register_protocol("Virtual Network Computing", "VNC", "vnc"); + vnc_handle = register_dissector("vnc", dissect_vnc, proto_vnc); + + /* Required function calls to register the header fields and subtrees */ + proto_register_field_array(proto_vnc, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + expert_vnc = expert_register_protocol(proto_vnc); + expert_register_field_array(expert_vnc, ei, array_length(ei)); + + /* Register our preferences module */ + vnc_module = prefs_register_protocol(proto_vnc, apply_vnc_prefs); + + prefs_register_bool_preference(vnc_module, "desegment", + "Reassemble VNC messages spanning multiple TCP segments.", + "Whether the VNC dissector should reassemble messages spanning " + "multiple TCP segments. To use this option, you must also enable " + "\"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.", + &vnc_preference_desegment); +} + +void +proto_reg_handoff_vnc(void) +{ + dissector_add_uint_range_with_preference("tcp.port", VNC_PORT_RANGE, vnc_handle); + heur_dissector_add("tcp", test_vnc_protocol, "VNC over TCP", "vnc_tcp", proto_vnc, HEURISTIC_ENABLE); + /* We don't register a port for the VNC HTTP server because + * that simply provides a java program for download via the + * HTTP protocol. The java program then connects to a standard + * VNC port. */ +} + +/* + * Editor modelines - https://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 8 + * tab-width: 8 + * indent-tabs-mode: t + * End: + * + * vi: set shiftwidth=8 tabstop=8 noexpandtab: + * :indentSize=8:tabSize=8:noTabs=false: + */ |