summaryrefslogtreecommitdiffstats
path: root/epan/dissectors/packet-x11.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-10 20:34:10 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-10 20:34:10 +0000
commite4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc (patch)
tree68cb5ef9081156392f1dd62a00c6ccc1451b93df /epan/dissectors/packet-x11.c
parentInitial commit. (diff)
downloadwireshark-e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc.tar.xz
wireshark-e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc.zip
Adding upstream version 4.2.2.upstream/4.2.2
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'epan/dissectors/packet-x11.c')
-rw-r--r--epan/dissectors/packet-x11.c6324
1 files changed, 6324 insertions, 0 deletions
diff --git a/epan/dissectors/packet-x11.c b/epan/dissectors/packet-x11.c
new file mode 100644
index 0000000..c4dcf9b
--- /dev/null
+++ b/epan/dissectors/packet-x11.c
@@ -0,0 +1,6324 @@
+/* packet-x11.c
+ * Routines for X11 dissection
+ * Copyright 2000, Christophe Tronche <ch.tronche@computer.org>
+ * Copyright 2003, Michael Shuldman
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+/* TODO (in no particular order):
+ *
+ * - keep track of Atom creation by server to be able to display
+ * non-predefined atoms
+ * - Idem for keysym <-> keycode ???
+ * - Idem for fonts
+ * - Subtree the request ids (that is x11.create-window.window and
+ * x11.change-window.window should be distinct), and add hidden fields
+ * (so we still have x11.window).
+ * - add hidden fields so we can have x11.circulate-window in addition to
+ * x11.opcode == 13 (but you could match on x11.opcode == "CirculateWindow"
+ * now)
+ * - add hidden fields so we have x11.listOfStuff.length
+ * - use a faster scheme that linear list searching for the opcode.
+ * - correct display of Unicode chars.
+ * - Not everything is homogeneous, in particular the handling of items in
+ * list is a total mess.
+ */
+
+/* By the way, I wrote a program to generate every request and test
+ * that stuff. If you're interested, you can get it at
+ * http://tronche.com/gui/x/
+ */
+
+#include "config.h"
+
+
+#include <epan/packet.h>
+#include <epan/exceptions.h>
+#include <epan/conversation.h>
+#include <epan/expert.h>
+#include <epan/show_exception.h>
+#include <epan/prefs.h>
+
+#include "packet-x11-keysymdef.h"
+#include "packet-x11.h"
+
+#include <wsutil/bits_count_ones.h>
+
+void proto_register_x11(void);
+void proto_reg_handoff_x11(void);
+
+static dissector_handle_t x11_handle = NULL;
+
+#define cVALS(x) (const value_string*)(x)
+
+
+/*
+ * Data structure associated with a conversation; keeps track of the
+ * request for which we're expecting a reply, the frame number of
+ * the initial connection request, and the byte order of the connection.
+ *
+ * An opcode of -3 means we haven't yet seen any requests yet.
+ * An opcode of -2 means we're not expecting a reply (unused).
+ * An opcode of -1 means we're waiting for a reply to the initial
+ * connection request.
+ * An opcode of 0 means the request was not seen (or unknown).
+ * Other values are the opcode of the request for which we're expecting
+ * a reply.
+ *
+ */
+#define NOTHING_SEEN -3
+#define NOTHING_EXPECTED -2
+#define INITIAL_CONN -1
+#define UNKNOWN_OPCODE 0
+
+#define MAX_OPCODES (255 + 1) /* 255 + INITIAL_CONN */
+#define LastExtensionError 255
+#define LastExtensionEvent 127
+
+#define BYTE_ORDER_UNKNOWN 0xFFFFFFFF
+
+static const char *modifiers[] = {
+ "Shift",
+ "Lock",
+ "Control",
+ "Mod1",
+ "Mod2",
+ "Mod3",
+ "Mod4",
+ "Mod5"
+};
+
+/* Keymasks. From <X11/X.h>. */
+#define ShiftMask (1<<0)
+#define LockMask (1<<1)
+#define ControlMask (1<<2)
+#define Mod1Mask (1<<3)
+#define Mod2Mask (1<<4)
+#define Mod3Mask (1<<5)
+#define Mod4Mask (1<<6)
+#define Mod5Mask (1<<7)
+
+static const int modifiermask[] = { ShiftMask, LockMask, ControlMask,
+Mod1Mask, Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask };
+
+/* from <X11/X.h> */
+#define NoSymbol 0L /* special KeySym */
+
+typedef struct _x11_conv_data {
+ wmem_map_t *seqtable; /* hashtable of sequencenumber <-> opcode. */
+ wmem_map_t *valtable; /* hashtable of sequencenumber <-> &opcode_vals */
+ /* major opcodes including extensions (NULL terminated) */
+ value_string opcode_vals[MAX_OPCODES+1];
+ /* error codes including extensions (NULL terminated) */
+ value_string errorcode_vals[LastExtensionError + 2];
+ /* event codes including extensions (NULL terminated) */
+ value_string eventcode_vals[LastExtensionEvent + 2];
+ wmem_map_t *eventcode_funcs; /* hashtable of eventcode <-> dissect_event() */
+ wmem_map_t *reply_funcs; /* hashtable of opcode <-> dissect_reply() */
+
+ int sequencenumber; /* sequencenumber of current packet. */
+ guint32 iconn_frame; /* frame # of initial connection request */
+ guint32 iconn_reply; /* frame # of initial connection reply */
+ guint byte_order; /* byte order of connection */
+ gboolean resync; /* resynchronization of sequence number performed */
+
+ int *keycodemap[256]; /* keycode to keysymvalue map. */
+ int keysyms_per_keycode;
+ int first_keycode;
+ int *modifiermap[array_length(modifiers)];/* modifier to keycode.*/
+ int keycodes_per_modifier;
+
+ union {
+ struct {
+ int first_keycode;
+ } GetKeyboardMapping;
+ } request;
+} x11_conv_data_t;
+
+static wmem_map_t *extension_table; /* hashtable of extension name <-> dispatch function */
+static wmem_map_t *event_table; /* hashtable of extension name <-> event info list */
+static wmem_map_t *genevent_table; /* hashtable of extension name <-> generic event info list */
+static wmem_map_t *error_table; /* hashtable of extension name <-> error list */
+static wmem_map_t *reply_table; /* hashtable of extension name <-> reply list */
+
+/* Initialize the protocol and registered fields */
+static int proto_x11 = -1;
+
+#include "x11-declarations.h"
+
+/* Initialize the subtree pointers */
+static gint ett_x11 = -1;
+static gint ett_x11_color_flags = -1;
+static gint ett_x11_list_of_arc = -1;
+static gint ett_x11_arc = -1;
+static gint ett_x11_list_of_atom = -1;
+static gint ett_x11_list_of_card32 = -1;
+static gint ett_x11_list_of_float = -1;
+static gint ett_x11_list_of_double = -1;
+static gint ett_x11_list_of_color_item = -1;
+static gint ett_x11_color_item = -1;
+static gint ett_x11_list_of_keycode = -1;
+static gint ett_x11_list_of_keysyms = -1;
+static gint ett_x11_keysym = -1;
+static gint ett_x11_list_of_point = -1;
+static gint ett_x11_point = -1;
+static gint ett_x11_list_of_rectangle = -1;
+static gint ett_x11_rectangle = -1;
+static gint ett_x11_list_of_segment = -1;
+static gint ett_x11_segment = -1;
+static gint ett_x11_list_of_string8 = -1;
+static gint ett_x11_list_of_text_item = -1;
+static gint ett_x11_text_item = -1;
+static gint ett_x11_gc_value_mask = -1; /* XXX - unused */
+static gint ett_x11_event_mask = -1; /* XXX - unused */
+static gint ett_x11_do_not_propagate_mask = -1; /* XXX - unused */
+static gint ett_x11_set_of_key_mask = -1;
+static gint ett_x11_pointer_event_mask = -1; /* XXX - unused */
+static gint ett_x11_window_value_mask = -1; /* XXX - unused */
+static gint ett_x11_configure_window_mask = -1; /* XXX - unused */
+static gint ett_x11_keyboard_value_mask = -1; /* XXX - unused */
+static gint ett_x11_same_screen_focus = -1;
+static gint ett_x11_event = -1;
+static gint ett_x11_list_of_pixmap_format = -1;
+static gint ett_x11_pixmap_format = -1;
+static gint ett_x11_list_of_screen = -1;
+static gint ett_x11_screen = -1;
+static gint ett_x11_list_of_depth_detail = -1;
+static gint ett_x11_depth_detail = -1;
+static gint ett_x11_list_of_visualtype= -1;
+static gint ett_x11_visualtype= -1;
+
+static expert_field ei_x11_invalid_format = EI_INIT;
+static expert_field ei_x11_request_length = EI_INIT;
+static expert_field ei_x11_keycode_value_out_of_range = EI_INIT;
+
+/* desegmentation of X11 messages */
+static gboolean x11_desegment = TRUE;
+
+#define DEFAULT_X11_PORT_RANGE "6000-6063"
+
+/*
+ * Round a length to a multiple of 4 bytes.
+ */
+#define ROUND_LENGTH(n) ((((n) + 3)/4) * 4)
+
+/************************************************************************
+ *** ***
+ *** E N U M T A B L E S D E F I N I T I O N S ***
+ *** ***
+ ************************************************************************/
+
+static const value_string byte_order_vals[] = {
+ { 'B', "Big-endian" },
+ { 'l', "Little-endian" },
+ { 0, NULL }
+};
+
+static const value_string image_byte_order_vals[] = {
+ { 0, "LSBFirst" },
+ { 1, "MSBFirst" },
+ { 0, NULL }
+};
+
+static const value_string access_mode_vals[] = {
+ { 0, "Disable" },
+ { 1, "Enable" },
+ { 0, NULL }
+};
+
+static const value_string all_temporary_vals[] = {
+ { 0, "AllTemporary" },
+ { 0, NULL }
+};
+
+static const value_string alloc_vals[] = {
+ { 0, "None" },
+ { 1, "All" },
+ { 0, NULL }
+};
+
+static const value_string allow_events_mode_vals[] = {
+ { 0, "AsyncPointer" },
+ { 1, "SyncPointer" },
+ { 2, "ReplayPointer" },
+ { 3, "AsyncKeyboard" },
+ { 4, "SyncKeyboard" },
+ { 5, "ReplayKeyboard" },
+ { 6, "AsyncBoth" },
+ { 7, "SyncBoth" },
+ { 0, NULL }
+};
+
+static const value_string arc_mode_vals[] = {
+ { 0, "Chord" },
+ { 1, "PieSlice" },
+ { 0, NULL }
+};
+
+static const char *atom_predefined_interpretation[] = {
+ "<error>",
+ "PRIMARY",
+ "SECONDARY",
+ "ARC",
+ "ATOM",
+ "BITMAP",
+ "CARDINAL",
+ "COLORMAP",
+ "CURSOR",
+ "CUT_BUFFER0",
+ "CUT_BUFFER1",
+ "CUT_BUFFER2",
+ "CUT_BUFFER3",
+ "CUT_BUFFER4",
+ "CUT_BUFFER5",
+ "CUT_BUFFER6",
+ "CUT_BUFFER7",
+ "DRAWABLE",
+ "FONT",
+ "INTEGER",
+ "PIXMAP",
+ "POINT",
+ "RECTANGLE",
+ "RESOURCE_MANAGER",
+ "RGB_COLOR_MAP",
+ "RGB_BEST_MAP",
+ "RGB_BLUE_MAP",
+ "RGB_DEFAULT_MAP",
+ "RGB_GRAY_MAP",
+ "RGB_GREEN_MAP",
+ "RGB_RED_MAP",
+ "STRING",
+ "VISUALID",
+ "WINDOW",
+ "WM_COMMAND",
+ "WM_HINTS",
+ "WM_CLIENT_MACHINE",
+ "WM_ICON_NAME",
+ "WM_ICON_SIZE",
+ "WM_NAME",
+ "WM_NORMAL_HINTS",
+ "WM_SIZE_HINTS",
+ "WM_ZOOM_HINTS",
+ "MIN_SPACE",
+ "NORM_SPACE",
+ "MAX_SPACE",
+ "END_SPACE",
+ "SUPERSCRIPT_X",
+ "SUPERSCRIPT_Y",
+ "SUBSCRIPT_X",
+ "SUBSCRIPT_Y",
+ "UNDERLINE_POSITION",
+ "UNDERLINE_THICKNESS",
+ "STRIKEOUT_ASCENT",
+ "STRIKEOUT_DESCENT",
+ "ITALIC_ANGLE",
+ "X_HEIGHT",
+ "QUAD_WIDTH",
+ "WEIGHT",
+ "POINT_SIZE",
+ "RESOLUTION",
+ "COPYRIGHT",
+ "NOTICE",
+ "FONT_NAME",
+ "FAMILY_NAME",
+ "FULL_NAME",
+ "CAP_HEIGHT",
+ "WM_CLASS",
+ "WM_TRANSIENT_FOR",
+};
+
+static const value_string auto_repeat_mode_vals[] = {
+ { 0, "Off" },
+ { 1, "On" },
+ { 2, "Default" },
+ { 0, NULL }
+};
+
+static const value_string background_pixmap_vals[] = {
+ { 0, "None" },
+ { 1, "ParentRelative" },
+ { 0, NULL }
+};
+
+static const value_string backing_store_vals[] = {
+ { 0, "NotUseful" },
+ { 1, "WhenMapped" },
+ { 2, "Always" },
+ { 0, NULL }
+};
+
+static const value_string border_pixmap_vals[] = {
+ { 0, "CopyFromParent" },
+ { 0, NULL }
+};
+
+static const value_string button_vals[] = {
+ { 0x8000, "AnyButton" },
+ { 0, NULL }
+};
+
+static const value_string cap_style_vals[] = {
+ { 0, "NotLast" },
+ { 1, "Butt" },
+ { 2, "Round" },
+ { 3, "Projecting" },
+ { 0, NULL }
+};
+
+static const value_string class_vals[] = {
+ { 0, "Cursor" },
+ { 1, "Tile" },
+ { 2, "Stipple" },
+ { 0, NULL }
+};
+
+static const value_string close_down_mode_vals[] = {
+ { 0, "Destroy" },
+ { 1, "RetainPermanent" },
+ { 2, "RetainTemporary" },
+ { 0, NULL }
+};
+
+static const value_string colormap_state_vals[] = {
+ { 0, "Uninstalled" },
+ { 1, "Installed" },
+ { 0, NULL }
+};
+
+static const value_string coordinate_mode_vals[] = {
+ { 0, "Origin" },
+ { 1, "Previous" },
+ { 0, NULL }
+};
+
+static const value_string destination_vals[] = {
+ { 0, "PointerWindow" },
+ { 1, "InputFocus" },
+ { 0, NULL }
+};
+
+static const value_string direction_vals[] = {
+ { 0, "RaiseLowest" },
+ { 1, "LowerHighest" },
+ { 0, NULL }
+};
+
+static const value_string event_detail_vals[] = {
+ { 0, "Ancestor" },
+ { 1, "Virtual" },
+ { 2, "Inferior" },
+ { 3, "Nonlinear" },
+ { 4, "NonlinearVirtual" },
+ { 0, NULL }
+};
+
+#define FAMILY_INTERNET 0
+#define FAMILY_DECNET 1
+#define FAMILY_CHAOS 2
+
+static const value_string family_vals[] = {
+ { FAMILY_INTERNET, "Internet" },
+ { FAMILY_DECNET, "DECnet" },
+ { FAMILY_CHAOS, "Chaos" },
+ { 0, NULL }
+};
+
+static const value_string fill_rule_vals[] = {
+ { 0, "EvenOdd" },
+ { 1, "Winding" },
+ { 0, NULL }
+};
+
+static const value_string fill_style_vals[] = {
+ { 0, "Solid" },
+ { 1, "Tiled" },
+ { 2, "Stippled" },
+ { 3, "OpaqueStippled" },
+ { 0, NULL }
+};
+
+static const value_string focus_detail_vals[] = {
+ { 0, "Ancestor" },
+ { 1, "Virtual" },
+ { 2, "Inferior" },
+ { 3, "Nonlinear" },
+ { 4, "NonlinearVirtual" },
+ { 5, "Pointer" },
+ { 6, "PointerRoot" },
+ { 7, "None" },
+ { 0, NULL }
+};
+
+static const value_string focus_mode_vals[] = {
+ { 0, "Normal" },
+ { 1, "Grab" },
+ { 2, "Ungrab" },
+ { 3, "WhileGrabbed" },
+ { 0, NULL }
+};
+
+static const value_string focus_vals[] = {
+ { 0, "None" },
+ { 1, "PointerRoot" },
+ { 0, NULL }
+};
+
+static const value_string function_vals[] = {
+ { 0, "Clear" },
+ { 1, "And" },
+ { 2, "AndReverse" },
+ { 3, "Copy" },
+ { 4, "AndInverted" },
+ { 5, "NoOp" },
+ { 6, "Xor" },
+ { 7, "Or" },
+ { 8, "Nor" },
+ { 9, "Equiv" },
+ { 10, "Invert" },
+ { 11, "OrReverse" },
+ { 12, "CopyInverted" },
+ { 13, "OrInverted" },
+ { 14, "Nand" },
+ { 15, "Set" },
+ { 0, NULL }
+};
+
+static const value_string grab_mode_vals[] = {
+ { 0, "Normal" },
+ { 1, "Grab" },
+ { 2, "Ungrab" },
+ { 0, NULL }
+};
+
+static const value_string grab_status_vals[] = {
+ { 0, "Success" },
+ { 1, "AlreadyGrabbed" },
+ { 2, "InvalidTime" },
+ { 3, "NotViewable" },
+ { 4, "Frozen" },
+ { 0, NULL }
+};
+
+static const value_string bit_gravity_vals[] = {
+ { 0, "Forget" },
+ { 1, "NorthWest" },
+ { 2, "North" },
+ { 3, "NorthEast" },
+ { 4, "West" },
+ { 5, "Center" },
+ { 6, "East" },
+ { 7, "SouthWest" },
+ { 8, "South" },
+ { 9, "SouthEast" },
+ { 10, "Static" },
+ { 0, NULL }
+};
+
+static const value_string win_gravity_vals[] = {
+ { 0, "Unmap" },
+ { 1, "NorthWest" },
+ { 2, "North" },
+ { 3, "NorthEast" },
+ { 4, "West" },
+ { 5, "Center" },
+ { 6, "East" },
+ { 7, "SouthWest" },
+ { 8, "South" },
+ { 9, "SouthEast" },
+ { 10, "Static" },
+ { 0, NULL }
+};
+
+static const value_string image_format_vals[] = {
+ { 0, "Bitmap" },
+ { 1, "XYPixmap" },
+ { 2, "ZPixmap" },
+ { 0, NULL }
+};
+
+static const value_string image_pixmap_format_vals[] = {
+ { 1, "XYPixmap" },
+ { 2, "ZPixmap" },
+ { 0, NULL }
+};
+
+static const value_string join_style_vals[] = {
+ { 0, "Miter" },
+ { 1, "Round" },
+ { 2, "Bevel" },
+ { 0, NULL }
+};
+
+static const value_string key_vals[] = {
+ { 0, "AnyKey" },
+ { 0, NULL }
+};
+
+#include "x11-keysym.h"
+
+static const value_string line_style_vals[] = {
+ { 0, "Solid" },
+ { 1, "OnOffDash" },
+ { 2, "DoubleDash" },
+ { 0, NULL }
+};
+
+static const value_string mode_vals[] = {
+ { 0, "Replace" },
+ { 1, "Prepend" },
+ { 2, "Append" },
+ { 0, NULL }
+};
+
+static const value_string on_off_vals[] = {
+ { 0, "Off" },
+ { 1, "On" },
+ { 0, NULL }
+};
+
+static const value_string place_vals[] = {
+ { 0, "Top" },
+ { 1, "Bottom" },
+ { 0, NULL }
+};
+
+static const value_string property_state_vals[] = {
+ { 0, "NewValue" },
+ { 1, "Deleted" },
+ { 0, NULL }
+};
+
+static const value_string visibility_state_vals[] = {
+ { 0, "Unobscured" },
+ { 1, "PartiallyObscured" },
+ { 2, "FullyObscured" },
+ { 0, NULL }
+};
+
+static const value_string mapping_request_vals[] = {
+ { 0, "MappingModifier" },
+ { 1, "MappingKeyboard" },
+ { 2, "MappingPointer" },
+ { 0, NULL }
+};
+
+/* Requestcodes. From <X11/Xproto.h>. */
+#define X_CreateWindow 1
+#define X_ChangeWindowAttributes 2
+#define X_GetWindowAttributes 3
+#define X_DestroyWindow 4
+#define X_DestroySubwindows 5
+#define X_ChangeSaveSet 6
+#define X_ReparentWindow 7
+#define X_MapWindow 8
+#define X_MapSubwindows 9
+#define X_UnmapWindow 10
+#define X_UnmapSubwindows 11
+#define X_ConfigureWindow 12
+#define X_CirculateWindow 13
+#define X_GetGeometry 14
+#define X_QueryTree 15
+#define X_InternAtom 16
+#define X_GetAtomName 17
+#define X_ChangeProperty 18
+#define X_DeleteProperty 19
+#define X_GetProperty 20
+#define X_ListProperties 21
+#define X_SetSelectionOwner 22
+#define X_GetSelectionOwner 23
+#define X_ConvertSelection 24
+#define X_SendEvent 25
+#define X_GrabPointer 26
+#define X_UngrabPointer 27
+#define X_GrabButton 28
+#define X_UngrabButton 29
+#define X_ChangeActivePointerGrab 30
+#define X_GrabKeyboard 31
+#define X_UngrabKeyboard 32
+#define X_GrabKey 33
+#define X_UngrabKey 34
+#define X_AllowEvents 35
+#define X_GrabServer 36
+#define X_UngrabServer 37
+#define X_QueryPointer 38
+#define X_GetMotionEvents 39
+#define X_TranslateCoords 40
+#define X_WarpPointer 41
+#define X_SetInputFocus 42
+#define X_GetInputFocus 43
+#define X_QueryKeymap 44
+#define X_OpenFont 45
+#define X_CloseFont 46
+#define X_QueryFont 47
+#define X_QueryTextExtents 48
+#define X_ListFonts 49
+#define X_ListFontsWithInfo 50
+#define X_SetFontPath 51
+#define X_GetFontPath 52
+#define X_CreatePixmap 53
+#define X_FreePixmap 54
+#define X_CreateGC 55
+#define X_ChangeGC 56
+#define X_CopyGC 57
+#define X_SetDashes 58
+#define X_SetClipRectangles 59
+#define X_FreeGC 60
+#define X_ClearArea 61
+#define X_CopyArea 62
+#define X_CopyPlane 63
+#define X_PolyPoint 64
+#define X_PolyLine 65
+#define X_PolySegment 66
+#define X_PolyRectangle 67
+#define X_PolyArc 68
+#define X_FillPoly 69
+#define X_PolyFillRectangle 70
+#define X_PolyFillArc 71
+#define X_PutImage 72
+#define X_GetImage 73
+#define X_PolyText8 74
+#define X_PolyText16 75
+#define X_ImageText8 76
+#define X_ImageText16 77
+#define X_CreateColormap 78
+#define X_FreeColormap 79
+#define X_CopyColormapAndFree 80
+#define X_InstallColormap 81
+#define X_UninstallColormap 82
+#define X_ListInstalledColormaps 83
+#define X_AllocColor 84
+#define X_AllocNamedColor 85
+#define X_AllocColorCells 86
+#define X_AllocColorPlanes 87
+#define X_FreeColors 88
+#define X_StoreColors 89
+#define X_StoreNamedColor 90
+#define X_QueryColors 91
+#define X_LookupColor 92
+#define X_CreateCursor 93
+#define X_CreateGlyphCursor 94
+#define X_FreeCursor 95
+#define X_RecolorCursor 96
+#define X_QueryBestSize 97
+#define X_QueryExtension 98
+#define X_ListExtensions 99
+#define X_ChangeKeyboardMapping 100
+#define X_GetKeyboardMapping 101
+#define X_ChangeKeyboardControl 102
+#define X_GetKeyboardControl 103
+#define X_Bell 104
+#define X_ChangePointerControl 105
+#define X_GetPointerControl 106
+#define X_SetScreenSaver 107
+#define X_GetScreenSaver 108
+#define X_ChangeHosts 109
+#define X_ListHosts 110
+#define X_SetAccessControl 111
+#define X_SetCloseDownMode 112
+#define X_KillClient 113
+#define X_RotateProperties 114
+#define X_ForceScreenSaver 115
+#define X_SetPointerMapping 116
+#define X_GetPointerMapping 117
+#define X_SetModifierMapping 118
+#define X_GetModifierMapping 119
+#define X_NoOperation 127
+#define X_FirstExtension 128
+#define X_LastExtension 255
+
+static const value_string opcode_vals[] = {
+ { INITIAL_CONN, "Initial connection request" },
+ { X_CreateWindow, "CreateWindow" },
+ { X_ChangeWindowAttributes, "ChangeWindowAttributes" },
+ { X_GetWindowAttributes, "GetWindowAttributes" },
+ { X_DestroyWindow, "DestroyWindow" },
+ { X_DestroySubwindows, "DestroySubwindows" },
+ { X_ChangeSaveSet, "ChangeSaveSet" },
+ { X_ReparentWindow, "ReparentWindow" },
+ { X_MapWindow, "MapWindow" },
+ { X_MapSubwindows, "MapSubwindows" },
+ { X_UnmapWindow, "UnmapWindow" },
+ { X_UnmapSubwindows, "UnmapSubwindows" },
+ { X_ConfigureWindow, "ConfigureWindow" },
+ { X_CirculateWindow, "CirculateWindow" },
+ { X_GetGeometry, "GetGeometry" },
+ { X_QueryTree, "QueryTree" },
+ { X_InternAtom, "InternAtom" },
+ { X_GetAtomName, "GetAtomName" },
+ { X_ChangeProperty, "ChangeProperty" },
+ { X_DeleteProperty, "DeleteProperty" },
+ { X_GetProperty, "GetProperty" },
+ { X_ListProperties, "ListProperties" },
+ { X_SetSelectionOwner, "SetSelectionOwner" },
+ { X_GetSelectionOwner, "GetSelectionOwner" },
+ { X_ConvertSelection, "ConvertSelection" },
+ { X_SendEvent, "SendEvent" },
+ { X_GrabPointer, "GrabPointer" },
+ { X_UngrabPointer, "UngrabPointer" },
+ { X_GrabButton, "GrabButton" },
+ { X_UngrabButton, "UngrabButton" },
+ { X_ChangeActivePointerGrab, "ChangeActivePointerGrab" },
+ { X_GrabKeyboard, "GrabKeyboard" },
+ { X_UngrabKeyboard, "UngrabKeyboard" },
+ { X_GrabKey, "GrabKey" },
+ { X_UngrabKey, "UngrabKey" },
+ { X_AllowEvents, "AllowEvents" },
+ { X_GrabServer, "GrabServer" },
+ { X_UngrabServer, "UngrabServer" },
+ { X_QueryPointer, "QueryPointer" },
+ { X_GetMotionEvents, "GetMotionEvents" },
+ { X_TranslateCoords, "TranslateCoordinates" },
+ { X_WarpPointer, "WarpPointer" },
+ { X_SetInputFocus, "SetInputFocus" },
+ { X_GetInputFocus, "GetInputFocus" },
+ { X_QueryKeymap, "QueryKeymap" },
+ { X_OpenFont, "OpenFont" },
+ { X_CloseFont, "CloseFont" },
+ { X_QueryFont, "QueryFont" },
+ { X_QueryTextExtents, "QueryTextExtents" },
+ { X_ListFonts, "ListFonts" },
+ { X_ListFontsWithInfo, "ListFontsWithInfo" },
+ { X_SetFontPath, "SetFontPath" },
+ { X_GetFontPath, "GetFontPath" },
+ { X_CreatePixmap, "CreatePixmap" },
+ { X_FreePixmap, "FreePixmap" },
+ { X_CreateGC, "CreateGC" },
+ { X_ChangeGC, "ChangeGC" },
+ { X_CopyGC, "CopyGC" },
+ { X_SetDashes, "SetDashes" },
+ { X_SetClipRectangles, "SetClipRectangles" },
+ { X_FreeGC, "FreeGC" },
+ { X_ClearArea, "ClearArea" },
+ { X_CopyArea, "CopyArea" },
+ { X_CopyPlane, "CopyPlane" },
+ { X_PolyPoint, "PolyPoint" },
+ { X_PolyLine, "PolyLine" },
+ { X_PolySegment, "PolySegment" },
+ { X_PolyRectangle, "PolyRectangle" },
+ { X_PolyArc, "PolyArc" },
+ { X_FillPoly, "FillPoly" },
+ { X_PolyFillRectangle, "PolyFillRectangle" },
+ { X_PolyFillArc, "PolyFillArc" },
+ { X_PutImage, "PutImage" },
+ { X_GetImage, "GetImage" },
+ { X_PolyText8, "PolyText8" },
+ { X_PolyText16, "PolyText16" },
+ { X_ImageText8, "ImageText8" },
+ { X_ImageText16, "ImageText16" },
+ { X_CreateColormap, "CreateColormap" },
+ { X_FreeColormap, "FreeColormap" },
+ { X_CopyColormapAndFree, "CopyColormapAndFree" },
+ { X_InstallColormap, "InstallColormap" },
+ { X_UninstallColormap, "UninstallColormap" },
+ { X_ListInstalledColormaps, "ListInstalledColormaps" },
+ { X_AllocColor, "AllocColor" },
+ { X_AllocNamedColor, "AllocNamedColor" },
+ { X_AllocColorCells, "AllocColorCells" },
+ { X_AllocColorPlanes, "AllocColorPlanes" },
+ { X_FreeColors, "FreeColors" },
+ { X_StoreColors, "StoreColors" },
+ { X_StoreNamedColor, "StoreNamedColor" },
+ { X_QueryColors, "QueryColors" },
+ { X_LookupColor, "LookupColor" },
+ { X_CreateCursor, "CreateCursor" },
+ { X_CreateGlyphCursor, "CreateGlyphCursor" },
+ { X_FreeCursor, "FreeCursor" },
+ { X_RecolorCursor, "RecolorCursor" },
+ { X_QueryBestSize, "QueryBestSize" },
+ { X_QueryExtension, "QueryExtension" },
+ { X_ListExtensions, "ListExtensions" },
+ { X_ChangeKeyboardMapping, "ChangeKeyboardMapping" },
+ { X_GetKeyboardMapping, "GetKeyboardMapping" },
+ { X_ChangeKeyboardControl, "ChangeKeyboardControl" },
+ { X_GetKeyboardControl, "GetKeyboardControl" },
+ { X_Bell, "Bell" },
+ { X_ChangePointerControl, "ChangePointerControl" },
+ { X_GetPointerControl, "GetPointerControl" },
+ { X_SetScreenSaver, "SetScreenSaver" },
+ { X_GetScreenSaver, "GetScreenSaver" },
+ { X_ChangeHosts, "ChangeHosts" },
+ { X_ListHosts, "ListHosts" },
+ { X_SetAccessControl, "SetAccessControl" },
+ { X_SetCloseDownMode, "SetCloseDownMode" },
+ { X_KillClient, "KillClient" },
+ { X_RotateProperties, "RotateProperties" },
+ { X_ForceScreenSaver, "ForceScreenSaver" },
+ { X_SetPointerMapping, "SetPointerMapping" },
+ { X_GetPointerMapping, "GetPointerMapping" },
+ { X_SetModifierMapping, "SetModifierMapping" },
+ { X_GetModifierMapping, "GetModifierMapping" },
+ { X_NoOperation, "NoOperation" },
+ { 0, NULL }
+};
+
+/* Eventscodes. From <X11/X.h>. */
+#define KeyPress 2
+#define KeyRelease 3
+#define ButtonPress 4
+#define ButtonRelease 5
+#define MotionNotify 6
+#define EnterNotify 7
+#define LeaveNotify 8
+#define FocusIn 9
+#define FocusOut 10
+#define KeymapNotify 11
+#define Expose 12
+#define GraphicsExpose 13
+#define NoExpose 14
+#define VisibilityNotify 15
+#define CreateNotify 16
+#define DestroyNotify 17
+#define UnmapNotify 18
+#define MapNotify 19
+#define MapRequest 20
+#define ReparentNotify 21
+#define ConfigureNotify 22
+#define ConfigureRequest 23
+#define GravityNotify 24
+#define ResizeRequest 25
+#define CirculateNotify 26
+#define CirculateRequest 27
+#define PropertyNotify 28
+#define SelectionClear 29
+#define SelectionRequest 30
+#define SelectionNotify 31
+#define ColormapNotify 32
+#define ClientMessage 33
+#define MappingNotify 34
+#define GenericEvent 35
+
+static const value_string eventcode_vals[] = {
+ { KeyPress, "KeyPress" },
+ { KeyRelease, "KeyRelease" },
+ { ButtonPress, "ButtonPress" },
+ { ButtonRelease, "ButtonRelease" },
+ { MotionNotify, "MotionNotify" },
+ { EnterNotify, "EnterNotify" },
+ { LeaveNotify, "LeaveNotify" },
+ { FocusIn, "FocusIn" },
+ { FocusOut, "FocusOut" },
+ { KeymapNotify, "KeymapNotify" },
+ { Expose, "Expose" },
+ { GraphicsExpose, "GraphicsExpose" },
+ { NoExpose, "NoExpose" },
+ { VisibilityNotify, "VisibilityNotify" },
+ { CreateNotify, "CreateNotify" },
+ { DestroyNotify, "DestroyNotify" },
+ { UnmapNotify, "UnmapNotify" },
+ { MapNotify, "MapNotify" },
+ { MapRequest, "MapRequest" },
+ { ReparentNotify, "ReparentNotify" },
+ { ConfigureNotify, "ConfigureNotify" },
+ { ConfigureRequest, "ConfigureRequest" },
+ { GravityNotify, "GravityNotify" },
+ { ResizeRequest, "ResizeRequest" },
+ { CirculateNotify, "CirculateNotify" },
+ { CirculateRequest, "CirculateRequest" },
+ { PropertyNotify, "PropertyNotify" },
+ { SelectionClear, "SelectionClear" },
+ { SelectionRequest, "SelectionRequest" },
+ { SelectionNotify, "SelectionNotify" },
+ { ColormapNotify, "ColormapNotify" },
+ { ClientMessage, "ClientMessage" },
+ { MappingNotify, "MappingNotify" },
+ { GenericEvent, "GenericEvent" },
+ { 0, NULL }
+};
+
+/* Errorcodes. From <X11/X.h> */
+#define Success 0 /* everything's okay */
+#define BadRequest 1 /* bad request code */
+#define BadValue 2 /* int parameter out of range */
+#define BadWindow 3 /* parameter not a Window */
+#define BadPixmap 4 /* parameter not a Pixmap */
+#define BadAtom 5 /* parameter not an Atom */
+#define BadCursor 6 /* parameter not a Cursor */
+#define BadFont 7 /* parameter not a Font */
+#define BadMatch 8 /* parameter mismatch */
+#define BadDrawable 9 /* parameter not a Pixmap or Window */
+#define BadAccess 10 /* depending on context:
+ - key/button already grabbed
+ - attempt to free an illegal
+ cmap entry
+ - attempt to store into a read-only
+ color map entry.
+ - attempt to modify the access control
+ list from other than the local host.
+ */
+#define BadAlloc 11 /* insufficient resources */
+#define BadColormap 12 /* no such colormap */
+#define BadGC 13 /* parameter not a GC */
+#define BadIDChoice 14 /* choice not in range or already used */
+#define BadName 15 /* font or color name doesn't exist */
+#define BadLength 16 /* Request length incorrect */
+#define BadImplementation 17 /* server is defective */
+
+static const value_string errorcode_vals[] = {
+ { Success, "Success" },
+ { BadRequest, "BadRequest" },
+ { BadValue, "BadValue" },
+ { BadWindow, "BadWindow" },
+ { BadPixmap, "BadPixmap" },
+ { BadAtom, "BadAtom" },
+ { BadCursor, "BadCursor" },
+ { BadFont, "BadFont" },
+ { BadMatch, "BadMatch" },
+ { BadDrawable, "BadDrawable" },
+ { BadAccess, "BadAccess" },
+ { BadAlloc, "BadAlloc" },
+ { BadColormap, "BadColormap" },
+ { BadGC, "BadGC" },
+ { BadIDChoice, "BadIDChoice" },
+ { BadName, "BadName" },
+ { BadLength, "BadLength" },
+ { BadImplementation, "BadImplementation" },
+ { 0, NULL }
+};
+
+static const value_string ordering_vals[] = {
+ { 0, "UnSorted" },
+ { 1, "YSorted" },
+ { 2, "YXSorted" },
+ { 3, "YXBanded" },
+ { 0, NULL }
+};
+
+static const value_string plane_mask_vals[] = {
+ { 0xFFFFFFFF, "AllPlanes" },
+ { 0, NULL }
+};
+
+static const value_string pointer_keyboard_mode_vals[] = {
+ { 0, "Synchronous" },
+ { 1, "Asynchronous" },
+ { 0, NULL }
+};
+
+static const value_string revert_to_vals[] = {
+ { 0, "None" },
+ { 1, "PointerRoot" },
+ { 2, "Parent" },
+ { 0, NULL }
+};
+
+static const value_string insert_delete_vals[] = {
+ { 0, "Insert" },
+ { 1, "Delete" },
+ { 0, NULL }
+};
+
+static const value_string screen_saver_mode_vals[] = {
+ { 0, "Reset" },
+ { 1, "Activate" },
+ { 0, NULL }
+};
+
+static const value_string shape_vals[] = {
+ { 0, "Complex" },
+ { 1, "Nonconvex" },
+ { 2, "Convex" },
+ { 0, NULL }
+};
+
+static const value_string stack_mode_vals[] = {
+ { 0, "Above" },
+ { 1, "Below" },
+ { 2, "TopIf" },
+ { 3, "BottomIf" },
+ { 4, "Opposite" },
+ { 0, NULL }
+};
+
+static const value_string subwindow_mode_vals[] = {
+ { 0, "ClipByChildren" },
+ { 1, "IncludeInferiors" },
+ { 0, NULL }
+};
+
+static const value_string window_class_vals[] = {
+ { 0, "CopyFromParent" },
+ { 1, "InputOutput" },
+ { 2, "InputOnly" },
+ { 0, NULL }
+};
+
+static const value_string yes_no_default_vals[] = {
+ { 0, "No" },
+ { 1, "Yes" },
+ { 2, "Default" },
+ { 0, NULL }
+};
+
+static const value_string zero_is_any_property_type_vals[] = {
+ { 0, "AnyPropertyType" },
+ { 0, NULL }
+};
+
+static const value_string zero_is_none_vals[] = {
+ { 0, "None" },
+ { 0, NULL }
+};
+
+/************************************************************************
+ *** ***
+ *** F I E L D D E C O D I N G M A C R O S ***
+ *** ***
+ ************************************************************************/
+#define FIELD8(name) (field8(tvb, offsetp, t, hf_x11_##name, byte_order))
+#define FIELD16(name) (field16(tvb, offsetp, t, hf_x11_##name, byte_order))
+#define FIELD32(name) (field32(tvb, offsetp, t, hf_x11_##name, byte_order))
+
+#define FLAG(position, name) {\
+ proto_tree_add_boolean(bitmask_tree, hf_x11_##position##_mask##_##name, tvb, bitmask_offset, bitmask_size, bitmask_value); }
+
+#define FLAG_IF_NONZERO(position, name) do {\
+ if (bitmask_value & proto_registrar_get_nth(hf_x11_##position##_mask##_##name) -> bitmask) \
+ proto_tree_add_boolean(bitmask_tree, hf_x11_##position##_mask##_##name, tvb, bitmask_offset, bitmask_size, bitmask_value); } while (0)
+
+#define ATOM(name) { atom(tvb, offsetp, t, hf_x11_##name, byte_order); }
+#define BOOL(name) (add_boolean(tvb, offsetp, t, hf_x11_##name))
+#define BUTTON(name) FIELD8(name)
+#define CARD8(name) FIELD8(name)
+#define CARD16(name) (FIELD16(name))
+#define CARD32(name) (FIELD32(name))
+#define COLOR_FLAGS(name) colorFlags(tvb, offsetp, t)
+#define COLORMAP(name) FIELD32(name)
+#define CURSOR(name) FIELD32(name)
+#define DRAWABLE(name) FIELD32(name)
+#define ENUM8(name) (FIELD8(name))
+#define ENUM16(name) (FIELD16(name))
+#define FONT(name) FIELD32(name)
+#define FONTABLE(name) FIELD32(name)
+#define GCONTEXT(name) FIELD32(name)
+#define INT8(name) FIELD8(name)
+#define INT16(name) FIELD16(name)
+#define INT32(name) FIELD32(name)
+#define KEYCODE(name) FIELD8(name)
+#define KEYCODE_DECODED(name, keycode, mask) do { \
+ proto_tree_add_uint_format(t, hf_x11_##name, tvb, offset, 1, \
+ keycode, "keycode: %d (%s)", \
+ keycode, keycode2keysymString(state->keycodemap, \
+ state->first_keycode, state->keysyms_per_keycode, \
+ state->modifiermap, state->keycodes_per_modifier, \
+ keycode, mask)); \
+ ++offset; \
+} while (0)
+#define EVENT() do { \
+ tvbuff_t *next_tvb; \
+ unsigned char eventcode; \
+ const char *sent; \
+ proto_tree *event_proto_tree; \
+ next_tvb = tvb_new_subset_length_caplen(tvb, offset, next_offset - offset, \
+ next_offset - offset); \
+ eventcode = tvb_get_guint8(next_tvb, 0); \
+ sent = (eventcode & 0x80) ? "Sent-" : ""; \
+ event_proto_tree = proto_tree_add_subtree_format(t, next_tvb, \
+ 0, -1, ett_x11_event, NULL, \
+ "event: %d (%s)", \
+ eventcode, \
+ val_to_str(eventcode & 0x7F, \
+ state->eventcode_vals, \
+ "<Unknown eventcode %u>")); \
+ decode_x11_event(next_tvb, eventcode, sent, event_proto_tree, \
+ state, byte_order); \
+ offset = next_offset; \
+} while (0)
+
+#define LISTofARC(name) { listOfArc(tvb, offsetp, t, hf_x11_##name, (next_offset - *offsetp) / 12, byte_order); }
+#define LISTofATOM(name, length) { listOfAtom(tvb, offsetp, t, hf_x11_##name, (length) / 4, byte_order); }
+#define LISTofBYTE(name, length) { listOfByte(tvb, offsetp, t, hf_x11_##name, (length), byte_order); }
+#define LISTofCARD8(name, length) { listOfByte(tvb, offsetp, t, hf_x11_##name, (length), byte_order); }
+#define LISTofIPADDRESS(name, length) { listOfByte(tvb, offsetp, t, hf_x11_##name, (length), FALSE); }
+#define LISTofCARD16(name, length) { listOfCard16(tvb, offsetp, t, hf_x11_##name, hf_x11_##name##_item, (length) / 2, byte_order); }
+#define LISTofCARD32(name, length) { listOfCard32(tvb, offsetp, t, hf_x11_##name, hf_x11_##name##_item, (length) / 4, byte_order); }
+#define LISTofCOLORITEM(name, length) { listOfColorItem(tvb, offsetp, t, hf_x11_##name, (length) / 12, byte_order); }
+#define LISTofKEYCODE(map, name, length) { listOfKeycode(tvb, offsetp, t, hf_x11_##name, map, (length), byte_order); }
+#define LISTofKEYSYM(name, map, keycode_first, keycode_count, \
+ keysyms_per_keycode) {\
+ listOfKeysyms(tvb, pinfo, offsetp, t, hf_x11_##name, hf_x11_##name##_item, map, (keycode_first), (keycode_count), (keysyms_per_keycode), byte_order); }
+#define LISTofPOINT(name, length) { listOfPoint(tvb, offsetp, t, hf_x11_##name, (length) / 4, byte_order); }
+#define LISTofRECTANGLE(name) { listOfRectangle(tvb, offsetp, t, hf_x11_##name, (next_offset - *offsetp) / 8, byte_order); }
+#define LISTofPIXMAPFORMAT(name, length) { listOfPixmapFormat(tvb, offsetp, t, hf_x11_##name, (length), byte_order); }
+#define LISTofSCREEN(name, length) { listOfScreen(tvb, offsetp, t, hf_x11_##name, (length), byte_order); }
+#define LISTofSEGMENT(name) { listOfSegment(tvb, offsetp, t, hf_x11_##name, (next_offset - *offsetp) / 8, byte_order); }
+#define LISTofSTRING8(name, length) { listOfString8(tvb, offsetp, t, hf_x11_##name, hf_x11_##name##_string, (length), byte_order); }
+#define LISTofTEXTITEM8(name) { listOfTextItem(tvb, offsetp, t, hf_x11_##name, FALSE, next_offset, byte_order); }
+#define LISTofTEXTITEM16(name) { listOfTextItem(tvb, offsetp, t, hf_x11_##name, TRUE, next_offset, byte_order); }
+#define OPCODE() { \
+ opcode = tvb_get_guint8(tvb, *offsetp); \
+ proto_tree_add_uint(t, hf_x11_opcode, tvb, *offsetp, \
+ 1, opcode); \
+ *offsetp += 1; \
+ }
+
+#define PIXMAP(name) { FIELD32(name); }
+#define REQUEST_LENGTH() (requestLength(tvb, offsetp, t, byte_order))
+#define SETofEVENT(name) { setOfEvent(tvb, offsetp, t, byte_order); }
+#define SETofDEVICEEVENT(name) { setOfDeviceEvent(tvb, offsetp, t, byte_order);}
+#define SETofKEYMASK(name) { setOfKeyButMask(tvb, offsetp, t, byte_order, 0); }
+#define SETofKEYBUTMASK(name) { setOfKeyButMask(tvb, offsetp, t, byte_order, 1); }
+#define SETofPOINTEREVENT(name) { setOfPointerEvent(tvb, offsetp, t, byte_order); }
+#define STRING8(name, length) { string8(tvb, offsetp, t, hf_x11_##name, length); }
+#define STRING16(name, length) { string16(tvb, offsetp, t, hf_x11_##name, hf_x11_##name##_bytes, length, byte_order); }
+#define TIMESTAMP(name){ timestamp(tvb, offsetp, t, hf_x11_##name, byte_order); }
+#define UNDECODED(x) { proto_tree_add_item(t, hf_x11_undecoded, tvb, *offsetp, x, ENC_NA); *offsetp += x; }
+#define PAD() { if (next_offset - *offsetp > 0) proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, next_offset - *offsetp, ENC_NA); *offsetp = next_offset; }
+#define WINDOW(name) { FIELD32(name); }
+
+#define VISUALID(name) { gint32 v = tvb_get_guint32(tvb, *offsetp, byte_order); \
+ proto_tree_add_uint_format(t, hf_x11_##name, tvb, *offsetp, 4, v, "Visualid: 0x%08x%s", v, \
+ v ? "" : " (CopyFromParent)"); *offsetp += 4; }
+#define REPLY(name) FIELD8(name);
+#define REPLYLENGTH(name) FIELD32(name);
+
+#define EVENTCONTENTS_COMMON() do { \
+ TIMESTAMP(time); \
+ WINDOW(rootwindow); \
+ WINDOW(eventwindow); \
+ WINDOW(childwindow); \
+ INT16(root_x); \
+ INT16(root_y); \
+ INT16(event_x); \
+ INT16(event_y); \
+ setOfKeyButMask(tvb, offsetp, t, byte_order, 1); \
+} while (0)
+
+#define SEQUENCENUMBER_REPLY(name) do { \
+ guint16 seqno; \
+ \
+ seqno = tvb_get_guint16(tvb, *offsetp, byte_order); \
+ proto_tree_add_uint_format(t, hf_x11_reply_##name, tvb, \
+ *offsetp, 2, seqno, \
+ "sequencenumber: %d (%s)", \
+ (int)seqno, \
+ val_to_str(opcode & 0xFF, state->opcode_vals, "<Unknown opcode %d>")); \
+ *offsetp += 2; \
+} while (0)
+
+#define REPLYCONTENTS_COMMON() do { \
+ REPLY(reply); \
+ proto_tree_add_item(t, hf_x11_undecoded, tvb, *offsetp, \
+ 1, ENC_NA); \
+ ++(*offsetp); \
+ SEQUENCENUMBER_REPLY(sequencenumber); \
+ REPLYLENGTH(replylength); \
+ proto_tree_add_item(t, hf_x11_undecoded, tvb, *offsetp, \
+ tvb_reported_length_remaining(tvb, *offsetp), ENC_NA); \
+ *offsetp += tvb_reported_length_remaining(tvb, *offsetp); \
+} while (0)
+
+
+#define HANDLE_REPLY(plen, length_remaining, str, func) do { \
+ if (length_remaining < plen) { \
+ if (x11_desegment && pinfo->can_desegment) { \
+ pinfo->desegment_offset = offset; \
+ pinfo->desegment_len = plen - length_remaining; \
+ return; \
+ } else { \
+ ; /* XXX yes, what then? Need to skip/join. */ \
+ } \
+ } \
+ if (length_remaining > plen) \
+ length_remaining = plen; \
+ next_tvb = tvb_new_subset_length_caplen(tvb, offset, length_remaining, plen); \
+ \
+ if (sep == NULL) { \
+ col_set_str(pinfo->cinfo, COL_INFO, str); \
+ sep = ":"; \
+ } \
+ \
+ TRY { \
+ func(next_tvb, pinfo, tree, sep, state, byte_order); \
+ } \
+ \
+ CATCH_NONFATAL_ERRORS { \
+ show_exception(next_tvb, pinfo, tree, EXCEPT_CODE, GET_MESSAGE); \
+ } \
+ ENDTRY; \
+ \
+ sep = ","; \
+} while (0)
+
+static void
+dissect_x11_initial_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+ const char *sep, x11_conv_data_t *state,
+ guint byte_order);
+
+static void
+dissect_x11_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+ const char *sep, x11_conv_data_t *state,
+ guint byte_order);
+
+static void
+dissect_x11_error(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+ const char *sep, x11_conv_data_t *state,
+ guint byte_order);
+
+static void
+dissect_x11_event(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+ const char *sep, x11_conv_data_t *state,
+ guint byte_order);
+
+static void
+decode_x11_event(tvbuff_t *tvb, unsigned char eventcode, const char *sent,
+ proto_tree *t, x11_conv_data_t *state,
+ guint byte_order);
+
+static x11_conv_data_t *
+x11_stateinit(conversation_t *conversation);
+
+static const char *
+keysymString(guint32 v);
+
+
+/************************************************************************
+ *** ***
+ *** D E C O D I N G F I E L D S ***
+ *** ***
+ ************************************************************************/
+
+static void atom(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ guint byte_order)
+{
+ const char *interpretation = NULL;
+
+ guint32 v = tvb_get_guint32(tvb, *offsetp, byte_order);
+ if (v >= 1 && v < array_length(atom_predefined_interpretation))
+ interpretation = atom_predefined_interpretation[v];
+ else if (v)
+ interpretation = "Not a predefined atom";
+ else {
+ header_field_info *hfi = proto_registrar_get_nth(hf);
+ if (hfi -> strings)
+ interpretation = try_val_to_str(v, cVALS(hfi -> strings));
+ }
+ if (!interpretation) interpretation = "error in Xlib client program ?";
+ proto_tree_add_uint_format(t, hf, tvb, *offsetp, 4, v, "%s: %u (%s)",
+ proto_registrar_get_nth(hf) -> name, v, interpretation);
+ *offsetp += 4;
+}
+
+static guint32 add_boolean(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf)
+{
+ guint32 v = tvb_get_guint8(tvb, *offsetp);
+ proto_tree_add_boolean(t, hf, tvb, *offsetp, 1, v);
+ *offsetp += 1;
+ return v;
+}
+
+static void colorFlags(tvbuff_t *tvb, int *offsetp, proto_tree *t)
+{
+ guint do_red_green_blue = tvb_get_guint8(tvb, *offsetp);
+ proto_item *ti;
+ proto_tree *tt;
+
+ if (do_red_green_blue) {
+ int sep = FALSE;
+ wmem_strbuf_t *buffer = wmem_strbuf_create(wmem_packet_scope());
+ wmem_strbuf_append(buffer, "flags: ");
+
+ if (do_red_green_blue & 0x1) {
+ wmem_strbuf_append(buffer, "DoRed");
+ sep = TRUE;
+ }
+
+ if (do_red_green_blue & 0x2) {
+ if (sep) wmem_strbuf_append(buffer, " | ");
+ wmem_strbuf_append(buffer, "DoGreen");
+ sep = TRUE;
+ }
+
+ if (do_red_green_blue & 0x4) {
+ if (sep) wmem_strbuf_append(buffer, " | ");
+ wmem_strbuf_append(buffer, "DoBlue");
+ sep = TRUE;
+ }
+
+ if (do_red_green_blue & 0xf8) {
+ if (sep) wmem_strbuf_append(buffer, " + trash");
+ }
+
+ ti = proto_tree_add_uint_format(t, hf_x11_coloritem_flags, tvb, *offsetp, 1, do_red_green_blue,
+ "%s", wmem_strbuf_get_str(buffer));
+ tt = proto_item_add_subtree(ti, ett_x11_color_flags);
+ if (do_red_green_blue & 0x1)
+ proto_tree_add_boolean(tt, hf_x11_coloritem_flags_do_red, tvb, *offsetp, 1,
+ do_red_green_blue & 0x1);
+ if (do_red_green_blue & 0x2)
+ proto_tree_add_boolean(tt, hf_x11_coloritem_flags_do_green, tvb, *offsetp, 1,
+ do_red_green_blue & 0x2);
+ if (do_red_green_blue & 0x4)
+ proto_tree_add_boolean(tt, hf_x11_coloritem_flags_do_blue, tvb, *offsetp, 1,
+ do_red_green_blue & 0x4);
+ if (do_red_green_blue & 0xf8)
+ proto_tree_add_boolean(tt, hf_x11_coloritem_flags_unused, tvb, *offsetp, 1,
+ do_red_green_blue & 0xf8);
+ } else
+ proto_tree_add_uint_format(t, hf_x11_coloritem_flags, tvb, *offsetp, 1, do_red_green_blue,
+ "flags: none");
+ *offsetp += 1;
+}
+
+static void listOfArc(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 8, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_arc);
+ while(length--) {
+ gint16 x = tvb_get_guint16(tvb, *offsetp, byte_order);
+ gint16 y = tvb_get_guint16(tvb, *offsetp + 2, byte_order);
+ guint16 width = tvb_get_guint16(tvb, *offsetp + 4, byte_order);
+ guint16 height = tvb_get_guint16(tvb, *offsetp + 6, byte_order);
+ gint16 angle1 = tvb_get_guint16(tvb, *offsetp + 8, byte_order);
+ gint16 angle2 = tvb_get_guint16(tvb, *offsetp + 10, byte_order);
+
+ proto_item *tti = proto_tree_add_none_format(tt, hf_x11_arc, tvb, *offsetp, 12,
+ "arc: %dx%d+%d+%d, angle %d -> %d (%f degrees -> %f degrees)",
+ width, height, x, y, angle1, angle2,
+ angle1 / 64.0, angle2 / 64.0);
+ proto_tree *ttt = proto_item_add_subtree(tti, ett_x11_arc);
+ proto_tree_add_int(ttt, hf_x11_arc_x, tvb, *offsetp, 2, x);
+ *offsetp += 2;
+ proto_tree_add_int(ttt, hf_x11_arc_y, tvb, *offsetp, 2, y);
+ *offsetp += 2;
+ proto_tree_add_uint(ttt, hf_x11_arc_width, tvb, *offsetp, 2, y);
+ *offsetp += 2;
+ proto_tree_add_uint(ttt, hf_x11_arc_height, tvb, *offsetp, 2, y);
+ *offsetp += 2;
+ proto_tree_add_int(ttt, hf_x11_arc_angle1, tvb, *offsetp, 2, y);
+ *offsetp += 2;
+ proto_tree_add_int(ttt, hf_x11_arc_angle2, tvb, *offsetp, 2, y);
+ *offsetp += 2;
+ }
+}
+
+static void listOfAtom(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 4, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_atom);
+ while(length--)
+ atom(tvb, offsetp, tt, hf_x11_properties_item, byte_order);
+}
+
+static void listOfByte(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int length, guint byte_order)
+{
+ if (length <= 0) length = 1;
+ proto_tree_add_item(t, hf, tvb, *offsetp, length, byte_order);
+ *offsetp += length;
+}
+
+static void listOfCard16(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int hf_item, int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 2, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_card32);
+ while(length--) {
+ proto_tree_add_item(tt, hf_item, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ }
+}
+
+static void listOfInt16(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int hf_item, int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 2, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_card32);
+ while(length--) {
+ proto_tree_add_item(tt, hf_item, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ }
+}
+
+static void listOfCard32(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int hf_item, int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 4, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_card32);
+ while(length--) {
+ proto_tree_add_item(tt, hf_item, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+}
+
+static void listOfInt32(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int hf_item, int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 4, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_card32);
+ while(length--) {
+ proto_tree_add_item(tt, hf_item, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+}
+
+static void listOfCard64(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int hf_item, int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 8, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_card32);
+ while(length--) {
+ proto_tree_add_item(tt, hf_item, tvb, *offsetp, 8, byte_order);
+ *offsetp += 8;
+ }
+}
+
+#if 0 /* Not yet used by any extension */
+static void listOfInt64(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int hf_item, int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 8, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_card32);
+ while(length--) {
+ proto_tree_add_item(tt, hf_item, tvb, *offsetp, 8, byte_order);
+ *offsetp += 8;
+ }
+}
+#endif
+
+static void listOfFloat(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int hf_item, int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 4, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_float);
+ while(length--) {
+ proto_tree_add_item(tt, hf_item, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+}
+
+static void listOfDouble(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int hf_item, int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 8, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_double);
+ while(length--) {
+ proto_tree_add_item(tt, hf_item, tvb, *offsetp, 8, byte_order);
+ *offsetp += 8;
+ }
+}
+
+static void listOfColorItem(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 8, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_color_item);
+ while(length--) {
+ proto_item *tti;
+ proto_tree *ttt;
+ guint do_red_green_blue;
+ guint16 red, green, blue;
+ wmem_strbuf_t *buffer;
+ const char *sep;
+
+ buffer=wmem_strbuf_create(wmem_packet_scope());
+ wmem_strbuf_append(buffer, "colorItem ");
+ red = tvb_get_guint16(tvb, *offsetp + 4, byte_order);
+ green = tvb_get_guint16(tvb, *offsetp + 6, byte_order);
+ blue = tvb_get_guint16(tvb, *offsetp + 8, byte_order);
+ do_red_green_blue = tvb_get_guint8(tvb, *offsetp + 10);
+
+ sep = "";
+ if (do_red_green_blue & 0x1) {
+ wmem_strbuf_append_printf(buffer, "red = %d", red);
+ sep = ", ";
+ }
+ if (do_red_green_blue & 0x2) {
+ wmem_strbuf_append_printf(buffer, "%sgreen = %d", sep, green);
+ sep = ", ";
+ }
+ if (do_red_green_blue & 0x4)
+ wmem_strbuf_append_printf(buffer, "%sblue = %d", sep, blue);
+
+ tti = proto_tree_add_none_format(tt, hf_x11_coloritem, tvb, *offsetp, 12, "%s", wmem_strbuf_get_str(buffer));
+ ttt = proto_item_add_subtree(tti, ett_x11_color_item);
+ proto_tree_add_item(ttt, hf_x11_coloritem_pixel, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ proto_tree_add_item(ttt, hf_x11_coloritem_red, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_coloritem_green, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_coloritem_blue, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ colorFlags(tvb, offsetp, ttt);
+ proto_tree_add_item(ttt, hf_x11_coloritem_unused, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ }
+}
+
+#if 0 /* XXX: Use of GTree no longer needed; use value_string_ext */
+static gint compareGuint32(gconstpointer a, gconstpointer b)
+{
+ return GPOINTER_TO_INT(b) - GPOINTER_TO_INT(a);
+}
+#endif
+
+static void
+XConvertCase(register int sym, int *lower, int *upper)
+{
+ *lower = sym;
+ *upper = sym;
+ switch(sym >> 8) {
+ case 0: /* Latin 1 */
+ if ((sym >= XK_A) && (sym <= XK_Z))
+ *lower += (XK_a - XK_A);
+ else if ((sym >= XK_a) && (sym <= XK_z))
+ *upper -= (XK_a - XK_A);
+ else if ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis))
+ *lower += (XK_agrave - XK_Agrave);
+ else if ((sym >= XK_agrave) && (sym <= XK_odiaeresis))
+ *upper -= (XK_agrave - XK_Agrave);
+ else if ((sym >= XK_Ooblique) && (sym <= XK_Thorn))
+ *lower += (XK_oslash - XK_Ooblique);
+ else if ((sym >= XK_oslash) && (sym <= XK_thorn))
+ *upper -= (XK_oslash - XK_Ooblique);
+ break;
+ case 1: /* Latin 2 */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym == XK_Aogonek)
+ *lower = XK_aogonek;
+ else if (sym >= XK_Lstroke && sym <= XK_Sacute)
+ *lower += (XK_lstroke - XK_Lstroke);
+ else if (sym >= XK_Scaron && sym <= XK_Zacute)
+ *lower += (XK_scaron - XK_Scaron);
+ else if (sym >= XK_Zcaron && sym <= XK_Zabovedot)
+ *lower += (XK_zcaron - XK_Zcaron);
+ else if (sym == XK_aogonek)
+ *upper = XK_Aogonek;
+ else if (sym >= XK_lstroke && sym <= XK_sacute)
+ *upper -= (XK_lstroke - XK_Lstroke);
+ else if (sym >= XK_scaron && sym <= XK_zacute)
+ *upper -= (XK_scaron - XK_Scaron);
+ else if (sym >= XK_zcaron && sym <= XK_zabovedot)
+ *upper -= (XK_zcaron - XK_Zcaron);
+ else if (sym >= XK_Racute && sym <= XK_Tcedilla)
+ *lower += (XK_racute - XK_Racute);
+ else if (sym >= XK_racute && sym <= XK_tcedilla)
+ *upper -= (XK_racute - XK_Racute);
+ break;
+ case 2: /* Latin 3 */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym >= XK_Hstroke && sym <= XK_Hcircumflex)
+ *lower += (XK_hstroke - XK_Hstroke);
+ else if (sym >= XK_Gbreve && sym <= XK_Jcircumflex)
+ *lower += (XK_gbreve - XK_Gbreve);
+ else if (sym >= XK_hstroke && sym <= XK_hcircumflex)
+ *upper -= (XK_hstroke - XK_Hstroke);
+ else if (sym >= XK_gbreve && sym <= XK_jcircumflex)
+ *upper -= (XK_gbreve - XK_Gbreve);
+ else if (sym >= XK_Cabovedot && sym <= XK_Scircumflex)
+ *lower += (XK_cabovedot - XK_Cabovedot);
+ else if (sym >= XK_cabovedot && sym <= XK_scircumflex)
+ *upper -= (XK_cabovedot - XK_Cabovedot);
+ break;
+ case 3: /* Latin 4 */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym >= XK_Rcedilla && sym <= XK_Tslash)
+ *lower += (XK_rcedilla - XK_Rcedilla);
+ else if (sym >= XK_rcedilla && sym <= XK_tslash)
+ *upper -= (XK_rcedilla - XK_Rcedilla);
+ else if (sym == XK_ENG)
+ *lower = XK_eng;
+ else if (sym == XK_eng)
+ *upper = XK_ENG;
+ else if (sym >= XK_Amacron && sym <= XK_Umacron)
+ *lower += (XK_amacron - XK_Amacron);
+ else if (sym >= XK_amacron && sym <= XK_umacron)
+ *upper -= (XK_amacron - XK_Amacron);
+ break;
+ case 6: /* Cyrillic */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym >= XK_Serbian_DJE && sym <= XK_Serbian_DZE)
+ *lower -= (XK_Serbian_DJE - XK_Serbian_dje);
+ else if (sym >= XK_Serbian_dje && sym <= XK_Serbian_dze)
+ *upper += (XK_Serbian_DJE - XK_Serbian_dje);
+ else if (sym >= XK_Cyrillic_YU && sym <= XK_Cyrillic_HARDSIGN)
+ *lower -= (XK_Cyrillic_YU - XK_Cyrillic_yu);
+ else if (sym >= XK_Cyrillic_yu && sym <= XK_Cyrillic_hardsign)
+ *upper += (XK_Cyrillic_YU - XK_Cyrillic_yu);
+ break;
+ case 7: /* Greek */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym >= XK_Greek_ALPHAaccent && sym <= XK_Greek_OMEGAaccent)
+ *lower += (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
+ else if (sym >= XK_Greek_alphaaccent && sym <= XK_Greek_omegaaccent &&
+ sym != XK_Greek_iotaaccentdieresis &&
+ sym != XK_Greek_upsilonaccentdieresis)
+ *upper -= (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
+ else if (sym >= XK_Greek_ALPHA && sym <= XK_Greek_OMEGA)
+ *lower += (XK_Greek_alpha - XK_Greek_ALPHA);
+ else if (sym >= XK_Greek_alpha && sym <= XK_Greek_omega &&
+ sym != XK_Greek_finalsmallsigma)
+ *upper -= (XK_Greek_alpha - XK_Greek_ALPHA);
+ break;
+ }
+}
+
+static const char *
+keycode2keysymString(int *keycodemap[256], int first_keycode,
+ int keysyms_per_keycode,
+ int *modifiermap[array_length(modifiers)],
+ int keycodes_per_modifier,
+ guint32 keycode, guint32 bitmask)
+{
+ int *syms;
+ int groupmodkc, numlockkc, numlockmod, groupmod;
+ int lockmod_is_capslock = 0, lockmod_is_shiftlock = 0;
+ int lockmod_is_nosymbol = 1;
+ int modifier, kc, keysym;
+
+ if ((syms = keycodemap[keycode]) == NULL)
+ return "<Unknown>";
+
+ for (kc = first_keycode, groupmodkc = numlockkc = -1; kc < 256; ++kc)
+ for (keysym = 0; keysym < keysyms_per_keycode; ++keysym) {
+ if (keycodemap[kc] == NULL)
+ return "<Unknown>";
+ switch (keycodemap[kc][keysym]) {
+ case 0xff7e:
+ groupmodkc = kc;
+ break;
+
+ case 0xff7f:
+ numlockkc = kc;
+ break;
+
+ case 0xffe5:
+ lockmod_is_capslock = kc;
+ break;
+
+ case 0xffe6:
+ lockmod_is_shiftlock = kc;
+ break;
+ }
+ }
+
+
+ /*
+ * If we have not seen the modifiermap we don't know what the
+ * keycode translates to, but we do know it's one of the keys
+ * in syms (give or take a case-conversion), so we could in
+ * theory list them all.
+ */
+ if (modifiermap[array_length(modifiers) - 1] == NULL) /* all or none */
+ return "<Unknown>";
+
+ /* find out what the numlockmodifer and groupmodifier is. */
+ for (modifier = 0, numlockmod = groupmod = -1;
+ modifier < (int)array_length(modifiers) && numlockmod == -1;
+ ++modifier)
+ for (kc = 0; kc < keycodes_per_modifier; ++kc)
+ if (modifiermap[modifier][kc] == numlockkc)
+ numlockmod = modifier;
+ else if (modifiermap[modifier][kc] == groupmodkc)
+ groupmod = modifier;
+
+ /*
+ * ... and what the lockmodifier is interpreted as.
+ * (X11v4r6 ref, keyboard and pointers section.)
+ */
+ for (kc = 0; kc < keycodes_per_modifier; ++kc)
+ if (modifiermap[1][kc] == lockmod_is_capslock) {
+ lockmod_is_shiftlock = lockmod_is_nosymbol = 0;
+ break;
+ }
+ else if (modifiermap[0][kc] == lockmod_is_shiftlock) {
+ lockmod_is_capslock = lockmod_is_nosymbol = 0;
+ break;
+ }
+
+#if 0
+ /*
+ * This is (how I understand) the X11v4R6 protocol description given
+ * in A. Nye's book. It is quite different from the
+ * code in _XTranslateKey() in the file
+ * "$XConsortium: KeyBind.c /main/55 1996/02/02 14:08:55 kaleb $"
+ * as shipped with XFree, and doesn't work correctly, nor do I see
+ * how it could (e.g. the case of lower/uppercase-letters).
+ * -- Michael Shuldman
+ */
+
+ if (numlockmod >= 0 && (bitmask & modifiermask[numlockmod])
+ && ((syms[1] >= 0xff80
+ && syms[1] <= 0xffbd)
+ || (syms[1] >= 0x11000000
+ && syms[1] <= 0x1100ffff))) {
+ if ((bitmask & ShiftMask) || lockmod_is_shiftlock)
+ return keysymString(syms[groupmod + 0]);
+ else
+ if (syms[groupmod + 1] == NoSymbol)
+ return keysymString(syms[groupmod + 0]);
+ else
+ return keysymString(syms[groupmod + 1]);
+ }
+ else if (!(bitmask & ShiftMask) && !(bitmask & LockMask))
+ return keysymString(syms[groupmod + 0]);
+ else if (!(bitmask & ShiftMask)
+ && ((bitmask & LockMask) && lockmod_is_capslock))
+ if (islower(syms[groupmod + 0]))
+/* return toupper(keysymString(syms[groupmod + 0])); */
+ return "Uppercase"; /* XXX */
+ else
+ return keysymString(syms[groupmod + 0]);
+
+ else if ((bitmask & ShiftMask)
+ && ((bitmask & LockMask) && lockmod_is_capslock))
+ if (islower(syms[groupmod + 1]))
+/* return toupper(keysymString(syms[groupmod + 1])); */
+ return "Uppercase"; /* XXX */
+ else
+ return keysymString(syms[groupmod + 1]);
+
+ else if ((bitmask & ShiftMask)
+ || ((bitmask & LockMask) && lockmod_is_shiftlock))
+ return keysymString(syms[groupmod + 1]);
+#else /* _XTranslateKey() based code. */
+
+ while (keysyms_per_keycode > 2
+ && keycodemap[keysyms_per_keycode - 1] == NoSymbol)
+ --keysyms_per_keycode;
+ if (keysyms_per_keycode > 2
+ && (groupmod >= 0 && (modifiermask[groupmod] & bitmask))) {
+ syms += 2;
+ keysyms_per_keycode -= 2;
+ }
+
+ if (numlockmod >= 0 && (bitmask & modifiermask[numlockmod])
+ && keysyms_per_keycode > 1
+ && ((syms[1] >= 0xff80 && syms[1] <= 0xffbd)
+ || (syms[1] >= 0x11000000 && syms[1] <= 0x1100ffff))) {
+ if ((bitmask & ShiftMask)
+ || (bitmask & LockMask && lockmod_is_shiftlock))
+ keysym = syms[0];
+ else
+ keysym = syms[1];
+ }
+ else if (!(bitmask & ShiftMask)
+ && (!(bitmask & LockMask) || lockmod_is_nosymbol)) {
+ if (keysyms_per_keycode == 1
+ || (keysyms_per_keycode > 1 && syms[1] == NoSymbol)) {
+ int usym;
+
+ XConvertCase(syms[0], &keysym, &usym);
+ }
+ else
+ keysym = syms[0];
+ }
+ else if (!(bitmask & LockMask) || !lockmod_is_capslock) {
+ int lsym, usym = 0;
+
+ if (keysyms_per_keycode == 1
+ || (keysyms_per_keycode > 1 && (usym = syms[1]) == NoSymbol))
+ XConvertCase(syms[0], &lsym, &usym);
+ keysym = usym;
+ }
+ else {
+ int lsym, usym = 0;
+
+ if (keysyms_per_keycode == 1
+ || (keysyms_per_keycode > 1 && syms[1] == NoSymbol))
+ keysym = syms[0];
+
+ XConvertCase(keysym, &lsym, &usym);
+
+ if (!(bitmask & ShiftMask) && keysym != syms[0]
+ && ((keysym != usym) || (lsym == usym)))
+ XConvertCase(syms[0], &lsym, &usym);
+ keysym = usym;
+ }
+
+ if (keysym == XK_VoidSymbol)
+ keysym = NoSymbol;
+
+ return wmem_strdup_printf(wmem_packet_scope(), "%d, \"%s\"", keysym, keysymString(keysym));
+#endif
+}
+
+static const char *keysymString(guint32 v)
+{
+#if 0 /* XXX: Use of GTree no longer needed; use value_string_ext */
+ static GTree *keysymTable = NULL;
+
+ gpointer res;
+ if (!keysymTable) {
+
+ /* This table is so big that we built it only if necessary */
+ const value_string *p = x11_keysym_vals_source;
+ keysymTable = g_tree_new(compareGuint32);
+ for(; p -> strptr; p++)
+ g_tree_insert(keysymTable, GINT_TO_POINTER(p -> value), (gpointer) (p -> strptr) );
+ }
+ res = g_tree_lookup(keysymTable, GINT_TO_POINTER(v));
+ return res ? res : "<Unknown>";
+#endif
+
+ return val_to_str_ext_const(v, &x11_keysym_vals_source_ext, "<Unknown>");
+
+}
+
+static void listOfKeycode(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int *modifiermap[], int keycodes_per_modifier,
+ guint byte_order _U_)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp,
+ (int)array_length(modifiers) * keycodes_per_modifier, ENC_NA);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_keycode);
+ size_t m;
+
+ for (m = 0; m < array_length(modifiers);
+ ++m, *offsetp += keycodes_per_modifier) {
+ proto_item *tikc;
+ int i;
+
+ tikc = proto_tree_add_bytes_format(tt, hf_x11_keycodes_item, tvb,
+ *offsetp, keycodes_per_modifier, NULL, "item: ");
+ modifiermap[m] = (int *)
+ wmem_alloc(wmem_file_scope(), sizeof(*modifiermap[m]) * keycodes_per_modifier);
+ for(i = 0; i < keycodes_per_modifier; ++i) {
+ guchar c = tvb_get_guint8(tvb, (*offsetp) + i);
+
+ if (c)
+ proto_item_append_text(tikc, " %s=%d", modifiers[m], c);
+
+ modifiermap[m][i] = c;
+ }
+ }
+}
+
+static void listOfKeysyms(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int hf,
+ int hf_item, int *keycodemap[256],
+ int keycode_first, int keycode_count,
+ int keysyms_per_keycode, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, keycode_count * keysyms_per_keycode * 4, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_keysyms);
+ proto_item *tti;
+ proto_tree *ttt;
+ int i, keycode;
+
+ DISSECTOR_ASSERT(keycode_first >= 0);
+ DISSECTOR_ASSERT(keycode_count >= 0);
+
+ for (keycode = keycode_first; keycode_count > 0;
+ ++keycode, --keycode_count) {
+ tti = proto_tree_add_none_format(tt, hf_item, tvb, *offsetp,
+ 4 * keysyms_per_keycode, "keysyms (keycode %d):", keycode);
+ if (keycode >= 256) {
+ expert_add_info_format(pinfo, tti, &ei_x11_keycode_value_out_of_range,
+ "keycode value %d is out of range", keycode);
+ *offsetp += 4 * keysyms_per_keycode;
+ continue;
+ }
+
+ ttt = proto_item_add_subtree(tti, ett_x11_keysym);
+
+ tvb_ensure_bytes_exist(tvb, *offsetp, 4 * keysyms_per_keycode);
+ keycodemap[keycode]
+ = (int *)wmem_alloc(wmem_file_scope(), sizeof(*keycodemap[keycode]) * keysyms_per_keycode);
+
+ for(i = 0; i < keysyms_per_keycode; ++i) {
+ /* keysymvalue = byte3 * 256 + byte4. */
+ guint32 v = tvb_get_guint32(tvb, *offsetp, byte_order);
+
+ proto_item_append_text(tti, " %s", keysymString(v));
+ proto_tree_add_uint_format(ttt, hf_x11_keysyms_item_keysym,
+ tvb, *offsetp, 4, v,
+ "keysym (keycode %d): 0x%08x (%s)",
+ keycode, v, keysymString(v));
+
+ keycodemap[keycode][i] = v;
+ *offsetp += 4;
+ }
+
+ for (i = 1; i < keysyms_per_keycode; ++i)
+ if (keycodemap[keycode][i] != NoSymbol)
+ break;
+
+ if (i == keysyms_per_keycode) {
+ /* all but (possibly) first were NoSymbol. */
+ if (keysyms_per_keycode == 4) {
+ keycodemap[keycode][1] = NoSymbol;
+ keycodemap[keycode][2] = keycodemap[keycode][0];
+ keycodemap[keycode][3] = NoSymbol;
+ }
+
+ continue;
+ }
+
+ for (i = 2; i < keysyms_per_keycode; ++i)
+ if (keycodemap[keycode][i] != NoSymbol)
+ break;
+ if (i == keysyms_per_keycode) {
+ /* all but (possibly) first two were NoSymbol. */
+ if (keysyms_per_keycode == 4) {
+ keycodemap[keycode][2] = keycodemap[keycode][0];
+ keycodemap[keycode][3] = keycodemap[keycode][1];
+ }
+
+ continue;
+ }
+ }
+}
+
+static void listOfPoint(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 4, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_point);
+ while(length--) {
+ gint16 x, y;
+ proto_item *tti;
+ proto_tree *ttt;
+
+ x = tvb_get_guint16(tvb, *offsetp, byte_order);
+ y = tvb_get_guint16(tvb, *offsetp + 2, byte_order);
+
+ tti = proto_tree_add_none_format(tt, hf_x11_point, tvb, *offsetp, 4, "point: (%d,%d)", x, y);
+ ttt = proto_item_add_subtree(tti, ett_x11_point);
+ proto_tree_add_int(ttt, hf_x11_point_x, tvb, *offsetp, 2, x);
+ *offsetp += 2;
+ proto_tree_add_int(ttt, hf_x11_point_y, tvb, *offsetp, 2, y);
+ *offsetp += 2;
+ }
+}
+
+static void listOfRectangle(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 8, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_rectangle);
+ while(length--) {
+ gint16 x, y;
+ guint width, height;
+ proto_item *tti;
+ proto_tree *ttt;
+
+ x = tvb_get_guint16(tvb, *offsetp, byte_order);
+ y = tvb_get_guint16(tvb, *offsetp + 2, byte_order);
+ width = tvb_get_guint16(tvb, *offsetp + 4, byte_order);
+ height = tvb_get_guint16(tvb, *offsetp + 6, byte_order);
+
+ tti = proto_tree_add_none_format(tt, hf_x11_rectangle, tvb, *offsetp, 8,
+ "rectangle: %dx%d+%d+%d", width, height, x, y);
+ ttt = proto_item_add_subtree(tti, ett_x11_rectangle);
+ proto_tree_add_int(ttt, hf_x11_rectangle_x, tvb, *offsetp, 2, x);
+ *offsetp += 2;
+ proto_tree_add_int(ttt, hf_x11_rectangle_y, tvb, *offsetp, 2, y);
+ *offsetp += 2;
+ proto_tree_add_uint(ttt, hf_x11_rectangle_width, tvb, *offsetp, 2, width);
+ *offsetp += 2;
+ proto_tree_add_uint(ttt, hf_x11_rectangle_height, tvb, *offsetp, 2, height);
+ *offsetp += 2;
+ }
+}
+
+static void listOfSegment(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 8, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_segment);
+ while(length--) {
+ gint16 x1, y1, x2, y2;
+ proto_item *tti;
+ proto_tree *ttt;
+
+ x1 = tvb_get_guint16(tvb, *offsetp, byte_order);
+ y1 = tvb_get_guint16(tvb, *offsetp + 2, byte_order);
+ x2 = tvb_get_guint16(tvb, *offsetp + 4, byte_order);
+ y2 = tvb_get_guint16(tvb, *offsetp + 6, byte_order);
+
+ tti = proto_tree_add_none_format(tt, hf_x11_segment, tvb, *offsetp, 8,
+ "segment: (%d,%d)-(%d,%d)", x1, y1, x2, y2);
+ ttt = proto_item_add_subtree(tti, ett_x11_segment);
+ proto_tree_add_item(ttt, hf_x11_segment_x1, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_segment_y1, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_segment_x2, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_segment_y2, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ }
+}
+
+static void listOfVisualTypes(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 24, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_visualtype);
+ while(length--) {
+ proto_item *tti;
+ proto_tree *ttt;
+
+ tti = proto_tree_add_none_format(tt, hf_x11_visualtype, tvb, *offsetp, 24,
+ "visualtype");
+ ttt = proto_item_add_subtree(tti, ett_x11_visualtype);
+ proto_tree_add_item(ttt, hf_x11_visualtype_visualid, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ proto_tree_add_item(ttt, hf_x11_visualtype_class, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(ttt, hf_x11_visualtype_bits_per_rgb_value, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(ttt, hf_x11_visualtype_colormap_entries, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_visualtype_red_mask, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ proto_tree_add_item(ttt, hf_x11_visualtype_green_mask, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ proto_tree_add_item(ttt, hf_x11_visualtype_blue_mask, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ proto_tree_add_item(ttt, hf_x11_unused, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+}
+static void listOfDepth(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int length, guint byte_order)
+{
+ guint16 number_of_visualtypes;
+ proto_item *ti;
+ proto_tree *tt;
+
+ ti = proto_tree_add_item(t, hf, tvb, *offsetp, -1, byte_order);
+ tt = proto_item_add_subtree(ti, ett_x11_list_of_depth_detail);
+ while(length--) {
+ proto_item *tti;
+ proto_tree *ttt;
+ number_of_visualtypes = tvb_get_guint16(tvb, *offsetp + 2, byte_order);
+
+ tti = proto_tree_add_none_format(tt, hf_x11_depth_detail, tvb, *offsetp, 8 + 24 * number_of_visualtypes,
+ "depth-detail");
+ ttt = proto_item_add_subtree(tti, ett_x11_screen);
+ proto_tree_add_item(ttt, hf_x11_depth_detail_depth, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(ttt, hf_x11_unused, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(ttt, hf_x11_depth_detail_visualtypes_numbers, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_unused, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ if (number_of_visualtypes > 0)
+ listOfVisualTypes(tvb, offsetp, ttt, hf_x11_visualtype, number_of_visualtypes, byte_order);
+ }
+}
+
+static void listOfScreen(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, -1, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_screen);
+ while(length--) {
+ guint8 number_of_depths, root_depth;
+ guint16 width_in_pixels, height_in_pixels;
+ guint32 screen_root;
+ proto_item *tti;
+ proto_tree *ttt;
+
+ screen_root = tvb_get_guint32(tvb, *offsetp, byte_order);
+ width_in_pixels = tvb_get_guint16(tvb, *offsetp + 20, byte_order);
+ height_in_pixels = tvb_get_guint16(tvb, *offsetp + 22, byte_order);
+ root_depth = tvb_get_guint8(tvb, *offsetp + 38);
+ tti = proto_tree_add_none_format(tt, hf_x11_screen, tvb, *offsetp, 0,
+ "screen (%08x: %d x %d x %d)", screen_root,
+ width_in_pixels, height_in_pixels, root_depth);
+ ttt = proto_item_add_subtree(tti, ett_x11_screen);
+ proto_tree_add_item(ttt, hf_x11_screen_root, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ proto_tree_add_item(ttt, hf_x11_screen_default_colormap, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ proto_tree_add_item(ttt, hf_x11_screen_white_pixel, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ proto_tree_add_item(ttt, hf_x11_screen_black_pixel, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ proto_tree_add_item(ttt, hf_x11_screen_current_input_masks, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ proto_tree_add_item(ttt, hf_x11_screen_width_in_pixels, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_screen_height_in_pixels, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_screen_width_in_millimeters, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_screen_height_in_millimeters, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_screen_min_installed_maps, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_screen_max_installed_maps, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(ttt, hf_x11_screen_root_visual, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ proto_tree_add_item(ttt, hf_x11_screen_backing_stores, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(ttt, hf_x11_screen_save_unders, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(ttt, hf_x11_screen_root_depth, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ number_of_depths = tvb_get_guint8(tvb, *offsetp);
+ proto_tree_add_item(ttt, hf_x11_screen_allowed_depths_len, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ listOfDepth(tvb, offsetp, ttt, hf_x11_depth_detail, number_of_depths, byte_order);
+ }
+}
+static void listOfPixmapFormat(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int length, guint byte_order)
+{
+ proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 8, byte_order);
+ proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_pixmap_format);
+ while(length--) {
+ proto_item *tti;
+ proto_tree *ttt;
+
+ tti = proto_tree_add_none_format(tt, hf_x11_pixmap_format, tvb, *offsetp, 8,
+ "pixmap-format");
+ ttt = proto_item_add_subtree(tti, ett_x11_pixmap_format);
+ proto_tree_add_item(ttt, hf_x11_pixmap_format_depth, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(ttt, hf_x11_pixmap_format_bits_per_pixel, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(ttt, hf_x11_pixmap_format_scanline_pad, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(ttt, hf_x11_unused, tvb, *offsetp, 5, byte_order);
+ *offsetp += 5;
+ }
+}
+
+static void listOfString8(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int hf_item, int length, guint byte_order)
+{
+ char *s = NULL;
+ proto_item *ti;
+ proto_tree *tt;
+ int i;
+
+ /* Compute total length */
+
+ int scanning_offset = *offsetp; /* Scanning pointer */
+ for(i = length; i; i--) {
+ int l;
+ l = tvb_get_guint8(tvb, scanning_offset);
+ scanning_offset += 1 + l;
+ }
+
+ ti = proto_tree_add_item(t, hf, tvb, *offsetp, scanning_offset - *offsetp, byte_order);
+ tt = proto_item_add_subtree(ti, ett_x11_list_of_string8);
+
+ while(length--) {
+ guint l = tvb_get_guint8(tvb, *offsetp);
+ s = tvb_get_string_enc(wmem_packet_scope(), tvb, *offsetp + 1, l, ENC_ASCII);
+ proto_tree_add_string_format(tt, hf_item, tvb, *offsetp, l + 1, s, "\"%s\"", s);
+ *offsetp += l + 1;
+ }
+}
+
+static int stringIsActuallyAn8BitString(tvbuff_t *tvb, int offset, guint length)
+{
+ for(; length > 0; offset += 2, length--) {
+ if (tvb_get_guint8(tvb, offset))
+ return FALSE;
+ }
+ return TRUE;
+}
+
+/* XXX - assumes that the string encoding is ASCII; even if 0x00 through
+ 0x7F are ASCII, 0x80 through 0xFF might not be, and even 0x00 through
+ 0x7F aren't necessarily ASCII. */
+static char *tvb_get_ascii_string16(tvbuff_t *tvb, int offset, guint length)
+{
+ wmem_strbuf_t *str;
+ guint8 ch;
+
+ str = wmem_strbuf_new_sized(wmem_packet_scope(), length + 1);
+
+ while(length--) {
+ offset++;
+ ch = tvb_get_guint8(tvb, offset);
+ if (ch < 0x80)
+ wmem_strbuf_append_c(str, ch);
+ else
+ wmem_strbuf_append_unichar_repl(str);
+ offset++;
+ }
+ return wmem_strbuf_finalize(str);
+}
+
+static void listOfTextItem(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int sizeIs16, int next_offset, guint byte_order)
+{
+ char *s = NULL;
+ proto_item *ti;
+ proto_tree *tt;
+ guint32 fid;
+
+ /* Compute total length */
+
+ int scanning_offset = *offsetp; /* Scanning pointer */
+ int n = 0; /* Number of items */
+
+ while(scanning_offset < next_offset) {
+ int l; /* Length of an individual item */
+ l = tvb_get_guint8(tvb, scanning_offset);
+ scanning_offset++;
+ if (!l) break;
+ n++;
+ scanning_offset += l == 255 ? 4 : l + (sizeIs16 ? l : 0) + 1;
+ }
+
+ ti = proto_tree_add_item(t, hf, tvb, *offsetp, scanning_offset - *offsetp, byte_order);
+ tt = proto_item_add_subtree(ti, ett_x11_list_of_text_item);
+
+ while(n--) {
+ guint l = tvb_get_guint8(tvb, *offsetp);
+ if (l == 255) { /* Item is a font */
+ fid = tvb_get_ntohl(tvb, *offsetp + 1);
+ proto_tree_add_uint(tt, hf_x11_textitem_font, tvb, *offsetp, 5, fid);
+ *offsetp += 5;
+ } else { /* Item is a string */
+ proto_item *tti;
+ proto_tree *ttt;
+ gint8 delta = tvb_get_guint8(tvb, *offsetp + 1);
+ if (sizeIs16) {
+ if (stringIsActuallyAn8BitString(tvb, *offsetp + 2, l)) {
+ s = tvb_get_ascii_string16(tvb, *offsetp + 2, l);
+ tti = proto_tree_add_none_format(tt, hf_x11_textitem_string, tvb, *offsetp, l*2 + 2,
+ "textitem (string): delta = %d, \"%s\"",
+ delta, s);
+ ttt = proto_item_add_subtree(tti, ett_x11_text_item);
+ proto_tree_add_item(ttt, hf_x11_textitem_string_delta, tvb, *offsetp + 1, 1, byte_order);
+ proto_tree_add_string_format_value(ttt, hf_x11_textitem_string_string16, tvb,
+ *offsetp + 2, l, s, "\"%s\"", s);
+ } else {
+ tti = proto_tree_add_none_format(tt, hf_x11_textitem_string, tvb, *offsetp, l*2 + 2,
+ "textitem (string): delta = %d, %s",
+ delta,
+ tvb_bytes_to_str(wmem_packet_scope(), tvb, *offsetp + 2, l*2));
+ ttt = proto_item_add_subtree(tti, ett_x11_text_item);
+ proto_tree_add_item(ttt, hf_x11_textitem_string_delta, tvb, *offsetp + 1, 1, byte_order);
+ proto_tree_add_item(ttt, hf_x11_textitem_string_string16_bytes, tvb, *offsetp + 2, l*2, byte_order);
+ }
+ *offsetp += l*2 + 2;
+ } else {
+ s = tvb_get_string_enc(wmem_packet_scope(), tvb, *offsetp + 2, l, ENC_ASCII);
+ tti = proto_tree_add_none_format(tt, hf_x11_textitem_string, tvb, *offsetp, l + 2,
+ "textitem (string): delta = %d, \"%s\"",
+ delta, s);
+ ttt = proto_item_add_subtree(tti, ett_x11_text_item);
+ proto_tree_add_item(ttt, hf_x11_textitem_string_delta, tvb, *offsetp + 1, 1, byte_order);
+ proto_tree_add_string_format(ttt, hf_x11_textitem_string_string8, tvb,
+ *offsetp + 2, l, s, "\"%s\"", s);
+ *offsetp += l + 2;
+ }
+ }
+ }
+}
+
+static guint32 field8(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ guint byte_order)
+{
+ guint32 v = tvb_get_guint8(tvb, *offsetp);
+ header_field_info *hfi = proto_registrar_get_nth(hf);
+ const gchar *enumValue = NULL;
+
+ if (hfi -> strings)
+ enumValue = try_val_to_str(v, cVALS(hfi -> strings));
+ if (enumValue)
+ proto_tree_add_uint_format(t, hf, tvb, *offsetp, 1, v,
+ hfi -> display == BASE_DEC ? "%s: %u (%s)" : "%s: 0x%02x (%s)",
+ hfi -> name, v, enumValue);
+ else
+ proto_tree_add_item(t, hf, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ return v;
+}
+
+static guint32 field16(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ guint byte_order)
+{
+ guint32 v = tvb_get_guint16(tvb, *offsetp, byte_order);
+ header_field_info *hfi = proto_registrar_get_nth(hf);
+ const gchar *enumValue = NULL;
+
+ if (hfi -> strings)
+ enumValue = try_val_to_str(v, cVALS(hfi -> strings));
+ if (enumValue)
+ proto_tree_add_uint_format(t, hf, tvb, *offsetp, 2, v,
+ hfi -> display == BASE_DEC ? "%s: %u (%s)" : "%s: 0x%02x (%s)",
+ hfi -> name, v, enumValue);
+ else
+ proto_tree_add_item(t, hf, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ return v;
+}
+
+static guint32 field32(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ guint byte_order)
+{
+ guint32 v = tvb_get_guint32(tvb, *offsetp, byte_order);
+ header_field_info *hfi = proto_registrar_get_nth(hf);
+ const gchar *enumValue = NULL;
+ const gchar *nameAsChar = hfi -> name;
+
+ if (hfi -> strings)
+ enumValue = try_val_to_str(v, cVALS(hfi -> strings));
+ if (enumValue)
+ proto_tree_add_uint_format(t, hf, tvb, *offsetp, 4, v,
+ hfi -> display == BASE_DEC ? "%s: %u (%s)" : "%s: 0x%08x (%s)",
+ nameAsChar, v, enumValue);
+ else
+ proto_tree_add_uint_format(t, hf, tvb, *offsetp, 4, v,
+ hfi -> display == BASE_DEC ? "%s: %u" : "%s: 0x%08x",
+ nameAsChar, v);
+ *offsetp += 4;
+ return v;
+}
+
+static int * const gc_mask_attributes[] = {
+ &hf_x11_gc_value_mask_function,
+ &hf_x11_gc_value_mask_plane_mask,
+ &hf_x11_gc_value_mask_foreground,
+ &hf_x11_gc_value_mask_background,
+ &hf_x11_gc_value_mask_line_width,
+ &hf_x11_gc_value_mask_line_style,
+ &hf_x11_gc_value_mask_cap_style,
+ &hf_x11_gc_value_mask_join_style,
+ &hf_x11_gc_value_mask_fill_style,
+ &hf_x11_gc_value_mask_fill_rule,
+ &hf_x11_gc_value_mask_tile,
+ &hf_x11_gc_value_mask_stipple,
+ &hf_x11_gc_value_mask_tile_stipple_x_origin,
+ &hf_x11_gc_value_mask_tile_stipple_y_origin,
+ &hf_x11_gc_value_mask_font,
+ &hf_x11_gc_value_mask_subwindow_mode,
+ &hf_x11_gc_value_mask_graphics_exposures,
+ &hf_x11_gc_value_mask_clip_x_origin,
+ &hf_x11_gc_value_mask_clip_y_origin,
+ &hf_x11_gc_value_mask_clip_mask,
+ &hf_x11_gc_value_mask_dash_offset,
+ &hf_x11_gc_value_mask_gc_dashes,
+ &hf_x11_gc_value_mask_arc_mode,
+ NULL
+};
+
+static void gcAttributes(tvbuff_t *tvb, int *offsetp, proto_tree *t,
+ guint byte_order)
+{
+ guint32 bitmask;
+ bitmask = tvb_get_guint32(tvb, *offsetp, byte_order);
+ proto_tree_add_bitmask(t, tvb, *offsetp, hf_x11_gc_value_mask, ett_x11_gc_value_mask, gc_mask_attributes, byte_order);
+ *offsetp += 4;
+
+ if (bitmask & 0x00000001) {
+ proto_tree_add_item(t, hf_x11_function, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00000002) {
+ proto_tree_add_item(t, hf_x11_plane_mask, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00000004) {
+ proto_tree_add_item(t, hf_x11_foreground, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00000008) {
+ proto_tree_add_item(t, hf_x11_background, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00000010) {
+ proto_tree_add_item(t, hf_x11_line_width, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask & 0x00000020) {
+ proto_tree_add_item(t, hf_x11_line_style, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00000040) {
+ proto_tree_add_item(t, hf_x11_cap_style, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00000080) {
+ proto_tree_add_item(t, hf_x11_join_style, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00000100) {
+ proto_tree_add_item(t, hf_x11_fill_style, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00000200) {
+ proto_tree_add_item(t, hf_x11_fill_rule, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00000400) {
+ proto_tree_add_item(t, hf_x11_tile, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00000800) {
+ proto_tree_add_item(t, hf_x11_stipple, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00001000) {
+ proto_tree_add_item(t, hf_x11_tile_stipple_x_origin, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask & 0x00002000) {
+ proto_tree_add_item(t, hf_x11_tile_stipple_y_origin, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask & 0x00004000) {
+ proto_tree_add_item(t, hf_x11_font, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00008000) {
+ proto_tree_add_item(t, hf_x11_subwindow_mode, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00010000) {
+ proto_tree_add_item(t, hf_x11_graphics_exposures, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00020000) {
+ proto_tree_add_item(t, hf_x11_clip_x_origin, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask & 0x00040000) {
+ proto_tree_add_item(t, hf_x11_clip_y_origin, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask & 0x00080000) {
+ proto_tree_add_item(t, hf_x11_clip_mask, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00100000) {
+ proto_tree_add_item(t, hf_x11_dash_offset, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask & 0x00200000) {
+ proto_tree_add_item(t, hf_x11_gc_dashes, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00400000) {
+ proto_tree_add_item(t, hf_x11_arc_mode, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+}
+
+static void gcMask(tvbuff_t *tvb, int *offsetp, proto_tree *t,
+ guint byte_order)
+{
+ proto_tree_add_bitmask(t, tvb, *offsetp, hf_x11_gc_value_mask, ett_x11_gc_value_mask, gc_mask_attributes, byte_order);
+ *offsetp += 4;
+}
+
+static guint32 requestLength(tvbuff_t *tvb, int *offsetp, proto_tree *t,
+ guint byte_order)
+{
+ guint32 res;
+ proto_item *ti = proto_tree_add_item_ret_uint(t, hf_x11_request_length, tvb, *offsetp, 2, byte_order, &res);
+ *offsetp += 2;
+ if (res == 0) {
+ proto_item_append_text(ti, " (extended length flag)");
+ proto_tree_add_item_ret_uint(t, hf_x11_request_length, tvb, *offsetp, 4, byte_order, &res);
+ *offsetp += 4;
+ }
+ return res * 4;
+}
+
+static void setOfEvent(tvbuff_t *tvb, int *offsetp, proto_tree *t,
+ guint byte_order)
+{
+ static int * const events[] = {
+ &hf_x11_event_mask_KeyPress,
+ &hf_x11_event_mask_KeyRelease,
+ &hf_x11_event_mask_ButtonPress,
+ &hf_x11_event_mask_ButtonRelease,
+ &hf_x11_event_mask_EnterWindow,
+ &hf_x11_event_mask_LeaveWindow,
+ &hf_x11_event_mask_PointerMotion,
+ &hf_x11_event_mask_PointerMotionHint,
+ &hf_x11_event_mask_Button1Motion,
+ &hf_x11_event_mask_Button2Motion,
+ &hf_x11_event_mask_Button3Motion,
+ &hf_x11_event_mask_Button4Motion,
+ &hf_x11_event_mask_Button5Motion,
+ &hf_x11_event_mask_ButtonMotion,
+ &hf_x11_event_mask_KeymapState,
+ &hf_x11_event_mask_Exposure,
+ &hf_x11_event_mask_VisibilityChange,
+ &hf_x11_event_mask_StructureNotify,
+ &hf_x11_event_mask_ResizeRedirect,
+ &hf_x11_event_mask_SubstructureNotify,
+ &hf_x11_event_mask_SubstructureRedirect,
+ &hf_x11_event_mask_FocusChange,
+ &hf_x11_event_mask_PropertyChange,
+ &hf_x11_event_mask_ColormapChange,
+ &hf_x11_event_mask_OwnerGrabButton,
+ NULL
+ };
+
+ proto_tree_add_bitmask(t, tvb, *offsetp, hf_x11_event_mask, ett_x11_event_mask, events, byte_order);
+ *offsetp += 4;
+}
+
+static void setOfDeviceEvent(tvbuff_t *tvb, int *offsetp, proto_tree *t,
+ guint byte_order)
+{
+ static int * const do_not_propagate_events[] = {
+ &hf_x11_do_not_propagate_mask_KeyPress,
+ &hf_x11_do_not_propagate_mask_KeyRelease,
+ &hf_x11_do_not_propagate_mask_ButtonPress,
+ &hf_x11_do_not_propagate_mask_ButtonRelease,
+ &hf_x11_do_not_propagate_mask_PointerMotion,
+ &hf_x11_do_not_propagate_mask_Button1Motion,
+ &hf_x11_do_not_propagate_mask_Button2Motion,
+ &hf_x11_do_not_propagate_mask_Button3Motion,
+ &hf_x11_do_not_propagate_mask_Button4Motion,
+ &hf_x11_do_not_propagate_mask_Button5Motion,
+ &hf_x11_do_not_propagate_mask_ButtonMotion,
+ NULL
+ };
+
+ proto_tree_add_bitmask(t, tvb, *offsetp, hf_x11_do_not_propagate_mask, ett_x11_do_not_propagate_mask, do_not_propagate_events, byte_order);
+ *offsetp += 4;
+}
+
+
+static void setOfKeyButMask(tvbuff_t *tvb, int *offsetp, proto_tree *t,
+ guint byte_order, gboolean butmask)
+{
+ proto_item *ti;
+ guint32 bitmask_value;
+ int bitmask_offset;
+ int bitmask_size;
+ proto_tree *bitmask_tree;
+
+ bitmask_value = tvb_get_guint16(tvb, *offsetp, byte_order);
+ bitmask_offset = *offsetp;
+ bitmask_size = 2;
+
+ if (!butmask && bitmask_value == 0x8000)
+ proto_tree_add_uint_format(t, hf_x11_modifiers_mask_AnyModifier, tvb, *offsetp, 2, 0x8000,
+ "modifiers-masks: 0x8000 (AnyModifier)");
+ else {
+ ti = proto_tree_add_uint(t, hf_x11_modifiers_mask, tvb, *offsetp, 2,
+ bitmask_value);
+ bitmask_tree = proto_item_add_subtree(ti, ett_x11_set_of_key_mask);
+ FLAG(modifiers, Shift);
+ FLAG(modifiers, Lock);
+ FLAG(modifiers, Control);
+ FLAG(modifiers, Mod1);
+ FLAG(modifiers, Mod2);
+ FLAG(modifiers, Mod3);
+ FLAG(modifiers, Mod4);
+ FLAG(modifiers, Mod5);
+
+ if (butmask) {
+ FLAG(modifiers, Button1);
+ FLAG(modifiers, Button2);
+ FLAG(modifiers, Button3);
+ FLAG(modifiers, Button4);
+ FLAG(modifiers, Button5);
+ }
+
+ if (butmask)
+ FLAG_IF_NONZERO(keybut, erroneous_bits);
+ else
+ FLAG_IF_NONZERO(modifiers, erroneous_bits);
+ }
+ *offsetp += 2;
+}
+
+static void setOfPointerEvent(tvbuff_t *tvb, int *offsetp, proto_tree *t,
+ guint byte_order)
+{
+ static int * const pointer_events[] = {
+ &hf_x11_pointer_event_mask_ButtonRelease,
+ &hf_x11_pointer_event_mask_EnterWindow,
+ &hf_x11_pointer_event_mask_LeaveWindow,
+ &hf_x11_pointer_event_mask_PointerMotion,
+ &hf_x11_pointer_event_mask_PointerMotionHint,
+ &hf_x11_pointer_event_mask_Button1Motion,
+ &hf_x11_pointer_event_mask_Button2Motion,
+ &hf_x11_pointer_event_mask_Button3Motion,
+ &hf_x11_pointer_event_mask_Button4Motion,
+ &hf_x11_pointer_event_mask_Button5Motion,
+ &hf_x11_pointer_event_mask_ButtonMotion,
+ &hf_x11_pointer_event_mask_KeymapState,
+ NULL
+ };
+
+ proto_tree_add_bitmask(t, tvb, *offsetp, hf_x11_pointer_event_mask, ett_x11_pointer_event_mask, pointer_events, byte_order);
+ *offsetp += 2;
+}
+
+static void string8(tvbuff_t *tvb, int *offsetp, proto_tree *t,
+ int hf, guint length)
+{
+ proto_tree_add_item(t, hf, tvb, *offsetp, length, ENC_NA|ENC_ASCII);
+ *offsetp += length;
+}
+
+/* The length supplied is the length of the string in CHAR2Bs (half the number of bytes) */
+
+static void string16(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ int hf_bytes, guint length, guint byte_order)
+{
+ guint l = length*2; /* byte count */
+ char *s;
+
+ if (stringIsActuallyAn8BitString(tvb, *offsetp, length)) {
+ s = tvb_get_ascii_string16(tvb, *offsetp, length);
+ proto_tree_add_string_format_value(t, hf, tvb, *offsetp, l, s, "\"%s\"", s);
+ } else
+ proto_tree_add_item(t, hf_bytes, tvb, *offsetp, l, byte_order);
+
+ *offsetp += l;
+}
+
+static void timestamp(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+ guint byte_order)
+{
+ guint32 v = tvb_get_guint32(tvb, *offsetp, byte_order);
+
+ if (!v)
+ proto_tree_add_uint_format(t, hf, tvb, *offsetp, 4, 0, "%s: 0 (CurrentTime)",
+ proto_registrar_get_nth(hf) -> name);
+ else
+ proto_tree_add_uint(t, hf, tvb, *offsetp, 4, v);
+ *offsetp += 4;
+}
+
+static void windowAttributes(tvbuff_t *tvb, int *offsetp, proto_tree *t,
+ guint byte_order)
+{
+ guint32 bitmask;
+ static int * const window_attributes_flags[] = {
+ &hf_x11_window_value_mask_background_pixmap,
+ &hf_x11_window_value_mask_background_pixel,
+ &hf_x11_window_value_mask_border_pixmap,
+ &hf_x11_window_value_mask_border_pixel,
+ &hf_x11_window_value_mask_bit_gravity,
+ &hf_x11_window_value_mask_win_gravity,
+ &hf_x11_window_value_mask_backing_store,
+ &hf_x11_window_value_mask_backing_planes,
+ &hf_x11_window_value_mask_backing_pixel,
+ &hf_x11_window_value_mask_override_redirect,
+ &hf_x11_window_value_mask_save_under,
+ &hf_x11_window_value_mask_event_mask,
+ &hf_x11_window_value_mask_do_not_propagate_mask,
+ &hf_x11_window_value_mask_colormap,
+ &hf_x11_window_value_mask_cursor,
+ NULL
+ };
+
+ bitmask = tvb_get_guint32(tvb, *offsetp, byte_order);
+ proto_tree_add_bitmask(t, tvb, *offsetp, hf_x11_window_value_mask, ett_x11_window_value_mask, window_attributes_flags, byte_order);
+ *offsetp += 4;
+
+ if (bitmask & 0x00000001) {
+ proto_tree_add_item(t, hf_x11_background_pixmap, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00000002) {
+ proto_tree_add_item(t, hf_x11_background_pixel, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00000004) {
+ proto_tree_add_item(t, hf_x11_border_pixmap, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00000008) {
+ proto_tree_add_item(t, hf_x11_border_pixel, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00000010) {
+ proto_tree_add_item(t, hf_x11_bit_gravity, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00000020) {
+ proto_tree_add_item(t, hf_x11_win_gravity, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00000040) {
+ proto_tree_add_item(t, hf_x11_backing_store, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00000080) {
+ proto_tree_add_item(t, hf_x11_backing_planes, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00000100) {
+ proto_tree_add_item(t, hf_x11_backing_pixel, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00000200) {
+ proto_tree_add_item(t, hf_x11_override_redirect, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00000400) {
+ proto_tree_add_item(t, hf_x11_save_under, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask & 0x00000800) {
+ setOfEvent(tvb, offsetp, t, byte_order);
+ }
+ if (bitmask & 0x00001000) {
+ setOfDeviceEvent(tvb, offsetp, t, byte_order);
+ }
+ if (bitmask & 0x00002000) {
+ proto_tree_add_item(t, hf_x11_colormap, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask & 0x00004000) {
+ proto_tree_add_item(t, hf_x11_cursor, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+}
+
+/************************************************************************
+ *** ***
+ *** G U E S S I N G T H E B Y T E O R D E R I N G ***
+ *** ***
+ ************************************************************************/
+
+/* If we can't guess, we return ENC_LITTLE_ENDIAN, cause
+ I'm developing on a Linux box :-). The (non-)guess isn't cached
+ however, so we may have more luck next time. I'm quite conservative
+ in my assertions, cause once it's cached, it stays in cache, and
+ we may be fooled up by a packet starting with the end of a request
+ started in a previous packet...
+*/
+
+static int numberOfBitSetTable[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
+
+static int numberOfBitSet(tvbuff_t *tvb, int offset, int maskLength)
+{
+ int res = 0;
+ while(maskLength--) {
+ int c = tvb_get_guint8(tvb, offset);
+ offset++;
+ res += numberOfBitSetTable[c & 0xf] + numberOfBitSetTable[c >> 4];
+ }
+ return res;
+}
+
+static int listOfStringLengthConsistent(tvbuff_t *tvb, int offset, int length, int listLength)
+{
+ if (listLength > length) return FALSE;
+ while(listLength--) {
+ int l;
+ if (!tvb_bytes_exist(tvb, offset, 1)) return TRUE;
+ l = tvb_get_guint8(tvb, offset);
+ if (!l) break;
+ l++;
+ if (l > length) return FALSE;
+ if (!tvb_bytes_exist(tvb, offset, l)) return TRUE;
+ offset += l;
+ length -= l;
+ }
+ if (length > 3) return FALSE;
+ return TRUE;
+}
+
+static int rounded4(int n)
+{
+ int remainder = n % 4;
+ int res = n / 4;
+ if (remainder) res++;
+ return res;
+}
+
+/* We assume the order to be consistent, until proven wrong. */
+
+static gboolean consistentWithOrder(int length, tvbuff_t *tvb, int offset, int encoding)
+{
+ switch(tvb_get_guint8(tvb, offset)) {
+ case X_CreateWindow:
+ return !tvb_bytes_exist(tvb, offset, 32) || length == 8 + numberOfBitSet(tvb, offset + 7 * 4, 4);
+
+ case X_ChangeWindowAttributes:
+ case X_ChangeGC:
+ return !tvb_bytes_exist(tvb, offset, 12) || length == 3 + numberOfBitSet(tvb, offset + 8, 4);
+
+ case X_GetWindowAttributes:
+ case X_DestroyWindow:
+ case X_DestroySubwindows:
+ case X_ChangeSaveSet:
+ case X_MapWindow:
+ case X_MapSubwindows:
+ case X_UnmapWindow:
+ case X_UnmapSubwindows:
+ case X_CirculateWindow:
+ case X_GetGeometry:
+ case X_QueryTree:
+ case X_GetAtomName:
+ case X_ListProperties:
+ case X_GetSelectionOwner:
+ case X_UngrabPointer:
+ case X_UngrabKeyboard:
+ case X_AllowEvents:
+ case X_QueryPointer:
+ case X_CloseFont:
+ case X_QueryFont:
+ case X_FreePixmap:
+ case X_FreeGC:
+ case X_FreeColormap:
+ case X_InstallColormap:
+ case X_UninstallColormap:
+ case X_ListInstalledColormaps:
+ case X_FreeCursor:
+ case X_GetKeyboardMapping:
+ case X_KillClient:
+ return length == 2;
+
+ case X_ReparentWindow:
+ case X_SetSelectionOwner:
+ case X_ChangeActivePointerGrab:
+ case X_GrabKeyboard:
+ case X_GrabKey:
+ case X_GetMotionEvents:
+ case X_TranslateCoords:
+ case X_CreatePixmap:
+ case X_CopyGC:
+ case X_ClearArea:
+ case X_CreateColormap:
+ case X_AllocColor:
+ case X_AllocColorPlanes:
+ return length == 4;
+
+ case X_ConfigureWindow:
+ return !tvb_bytes_exist(tvb, offset, 10) || length == 3 + numberOfBitSet(tvb, offset + 8, 2);
+
+ case X_InternAtom:
+ case X_QueryExtension:
+ return !tvb_bytes_exist(tvb, offset, 6) || length == 2 + rounded4(tvb_get_guint16(tvb, offset + 4, encoding));
+
+ case X_ChangeProperty:
+ {
+ int multiplier, type;
+ if (!tvb_bytes_exist(tvb, offset, 17)) return TRUE;
+ type = tvb_get_guint8(tvb, 16);
+ if (type != 8 && type != 16 && type != 32) return FALSE;
+ multiplier = type == 8 ? 1 : type == 16 ? 2 : 4;
+ if (!tvb_bytes_exist(tvb, offset, 24)) return TRUE;
+ return length == 6 + rounded4(tvb_get_guint32(tvb, offset + 20, encoding) * multiplier);
+ }
+
+ case X_DeleteProperty:
+ case X_UngrabButton:
+ case X_UngrabKey:
+ case X_SetInputFocus:
+ case X_CopyColormapAndFree:
+ case X_AllocColorCells:
+ case X_QueryBestSize:
+ case X_ChangePointerControl:
+ case X_SetScreenSaver:
+ return length == 3;
+
+ case X_GetProperty:
+ case X_ConvertSelection:
+ case X_GrabPointer:
+ case X_GrabButton:
+ case X_WarpPointer:
+ return length == 6;
+
+ case X_SendEvent:
+ return length == 11;
+
+ case X_GrabServer:
+ case X_UngrabServer:
+ case X_GetInputFocus:
+ case X_QueryKeymap:
+ case X_GetFontPath:
+ case X_ListExtensions:
+ case X_GetKeyboardControl:
+ case X_Bell:
+ case X_GetPointerControl:
+ case X_GetScreenSaver:
+ case X_ListHosts:
+ case X_SetAccessControl:
+ case X_SetCloseDownMode:
+ case X_ForceScreenSaver:
+ case X_GetPointerMapping:
+ case X_GetModifierMapping:
+ return length == 1;
+
+ case X_OpenFont:
+ case X_AllocNamedColor:
+ case X_LookupColor:
+ return !tvb_bytes_exist(tvb, offset, 10) || length == 3 + rounded4(tvb_get_guint16(tvb, offset + 8, encoding));
+
+ case X_QueryTextExtents:
+ return length >= 2;
+
+ case X_ListFonts:
+ case X_ListFontsWithInfo:
+ case X_ChangeHosts:
+ return !tvb_bytes_exist(tvb, offset, 8) || length == 2 + rounded4(tvb_get_guint16(tvb, offset + 6, encoding));
+
+ case X_SetFontPath:
+ if (length < 2) return FALSE;
+ if (!tvb_bytes_exist(tvb, offset, 8)) return TRUE;
+ return listOfStringLengthConsistent(tvb, offset + 8, (length - 2) * 4, tvb_get_guint16(tvb, offset + 4, encoding));
+
+ case X_CreateGC:
+ return !tvb_bytes_exist(tvb, offset, 16) || length == 4 + numberOfBitSet(tvb, offset + 12, 4);
+
+ case X_SetDashes:
+ return !tvb_bytes_exist(tvb, offset, 12) || length == 3 + rounded4(tvb_get_guint16(tvb, offset + 10, encoding));
+
+ case X_SetClipRectangles:
+ case X_PolySegment:
+ case X_PolyRectangle:
+ case X_PolyFillRectangle:
+ return length >= 3 && (length - 3) % 2 == 0;
+
+ case X_CopyArea:
+ return length == 7;
+
+ case X_CopyPlane:
+ case X_CreateCursor:
+ case X_CreateGlyphCursor:
+ return length == 8;
+
+ case X_PolyPoint:
+ case X_PolyLine:
+ case X_FreeColors:
+ return length >= 3;
+
+ case X_PolyArc:
+ case X_PolyFillArc:
+ return length >= 3 && (length - 3) % 3 == 0;
+
+ case X_FillPoly:
+ case X_ImageText8:
+ return length >= 4;
+
+ case X_PutImage:
+ return length >= 6;
+
+ case X_GetImage:
+ case X_RecolorCursor:
+ return length == 5;
+
+ case X_PolyText8:
+ if (length < 4) return FALSE;
+ return TRUE; /* We don't perform many controls on this one */
+
+ case X_PolyText16:
+ if (length < 4) return FALSE;
+ return TRUE; /* We don't perform many controls on this one */
+
+ case X_ImageText16:
+ return length >= 4;
+
+ case X_StoreColors:
+ return length > 2 && (length - 2) % 3 == 0;
+
+ case X_StoreNamedColor:
+ return !tvb_bytes_exist(tvb, offset, 14) || length == 4 + rounded4(tvb_get_guint16(tvb, offset + 12, encoding));
+
+ case X_QueryColors:
+ return length >= 2;
+
+ case X_ChangeKeyboardMapping:
+ return !tvb_bytes_exist(tvb, offset, 6) || length == 2 + tvb_get_guint8(tvb, 1) * tvb_get_guint8(tvb, 5);
+
+ case X_ChangeKeyboardControl:
+ return !tvb_bytes_exist(tvb, offset, 6) || length == 2 + numberOfBitSet(tvb, offset + 4, 2);
+
+ case X_RotateProperties:
+ return !tvb_bytes_exist(tvb, offset, 10) || length == 3 + tvb_get_guint16(tvb, offset + 8, encoding);
+
+ case X_SetPointerMapping:
+ return length == 1 + rounded4(tvb_get_guint8(tvb, 1));
+
+ case X_SetModifierMapping:
+ return length == 1 + tvb_get_guint8(tvb, 1) * 2;
+
+ case X_NoOperation:
+ return length >= 1;
+
+ default:
+ return TRUE;
+ }
+}
+
+/* -1 means doesn't match, +1 means match, 0 means don't know */
+
+static int x_endian_match(tvbuff_t *tvb, int encoding)
+{
+ int offset, nextoffset;
+ int atLeastOne = 0;
+
+ for(offset = 0; tvb_bytes_exist(tvb, offset, 4); offset = nextoffset) {
+ int length;
+ length = tvb_get_guint16(tvb, offset + 2, encoding);
+ if (!length)
+ return -1;
+ nextoffset = offset + length * 4;
+ if (!consistentWithOrder(length, tvb, offset, encoding))
+ return -1;
+ atLeastOne = 1;
+ }
+ return atLeastOne;
+}
+
+static guint
+guess_byte_ordering(tvbuff_t *tvb, packet_info *pinfo,
+ x11_conv_data_t *state)
+{
+ /* With X the client gives the byte ordering for the protocol,
+ and the port on the server tells us we're speaking X. */
+
+ int le, be;
+ guint decision;
+
+ if (state->byte_order == ENC_BIG_ENDIAN)
+ return ENC_BIG_ENDIAN; /* known to be big-endian */
+ else if (state->byte_order == ENC_LITTLE_ENDIAN)
+ return ENC_LITTLE_ENDIAN; /* known to be little-endian */
+
+ if (pinfo->srcport == pinfo->match_uint) {
+ /*
+ * This is a reply or event; we don't try to guess the
+ * byte order on it for now.
+ */
+ return ENC_LITTLE_ENDIAN;
+ }
+
+ le = x_endian_match(tvb, ENC_LITTLE_ENDIAN);
+ be = x_endian_match(tvb, ENC_BIG_ENDIAN);
+
+ if (le == be) {
+ /* We have no reason to believe it's little- rather than
+ big-endian, so we guess the shortest length is the
+ right one.
+ */
+ if (!tvb_bytes_exist(tvb, 0, 4))
+ /* Not even a way to get the length. We're biased
+ toward little endianness here (essentially the
+ x86 world right now). Decoding won't go very far
+ anyway.
+ */
+ decision = ENC_LITTLE_ENDIAN;
+ else {
+ if (tvb_get_letohs(tvb, 2) <= tvb_get_ntohs(tvb, 2))
+ decision = ENC_LITTLE_ENDIAN;
+ else
+ decision = ENC_BIG_ENDIAN;
+ }
+ } else {
+ if (le >= be)
+ decision = ENC_LITTLE_ENDIAN;
+ else
+ decision = ENC_BIG_ENDIAN;
+ }
+
+ if ((le < 0 && be > 0) || (le > 0 && be < 0)) {
+ /*
+ * Remember the decision.
+ */
+ state->byte_order = decision;
+ }
+
+ return decision;
+}
+
+/************************************************************************
+ *** ***
+ *** D E C O D I N G O N E P A C K E T ***
+ *** ***
+ ************************************************************************/
+
+/*
+ * Decode an initial connection request.
+ */
+static void dissect_x11_initial_conn(tvbuff_t *tvb, packet_info *pinfo,
+ proto_tree *tree, x11_conv_data_t *state, guint byte_order)
+{
+ int offset = 0;
+ int *offsetp = &offset;
+ proto_item *ti;
+ proto_tree *t;
+ guint16 auth_proto_name_length, auth_proto_data_length;
+ gint left;
+
+ ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
+ proto_item_append_text(ti, ", Request, Initial connection request");
+ t = proto_item_add_subtree(ti, ett_x11);
+
+ CARD8(byte_order);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(protocol_major_version);
+ CARD16(protocol_minor_version);
+ auth_proto_name_length = CARD16(authorization_protocol_name_length);
+ auth_proto_data_length = CARD16(authorization_protocol_data_length);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+
+ if (auth_proto_name_length != 0) {
+ STRING8(authorization_protocol_name, auth_proto_name_length);
+ offset = ROUND_LENGTH(offset);
+ }
+
+ if (auth_proto_data_length != 0) {
+ STRING8(authorization_protocol_data, auth_proto_data_length);
+ offset = ROUND_LENGTH(offset);
+ }
+
+ if ((left = tvb_reported_length_remaining(tvb, offset)) > 0)
+ proto_tree_add_item(t, hf_x11_undecoded, tvb, offset, left,
+ ENC_NA);
+
+ /*
+ * This is the initial connection request...
+ */
+ state->iconn_frame = pinfo->num;
+
+ /*
+ * ...and we're expecting a reply to it.
+ */
+ state->sequencenumber = 0;
+ wmem_map_insert(state->seqtable, GINT_TO_POINTER(state->sequencenumber),
+ (int *)INITIAL_CONN);
+}
+
+static void dissect_x11_initial_reply(tvbuff_t *tvb, packet_info *pinfo,
+ proto_tree *tree, const char _U_ *sep, x11_conv_data_t *state,
+ guint byte_order)
+{
+ int offset = 0, *offsetp = &offset, left;
+ unsigned char success;
+ int length_of_vendor;
+ int length_of_reason;
+ int number_of_formats_in_pixmap_formats;
+ int number_of_screens_in_roots;
+ int unused;
+ proto_item *ti;
+ proto_tree *t;
+
+ ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
+ proto_item_append_text(ti, ", Reply, Initial connection reply");
+ t = proto_item_add_subtree(ti, ett_x11);
+
+ state->iconn_reply = pinfo->num;
+ success = INT8(success);
+ if (success) {
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ length_of_reason = 0;
+ }
+ else {
+ length_of_reason = INT8(length_of_reason);
+ }
+
+ INT16(protocol_major_version);
+ INT16(protocol_minor_version);
+ INT16(replylength);
+ if (success) {
+ INT32(release_number);
+ INT32(resource_id_base);
+ INT32(resource_id_mask);
+ INT32(motion_buffer_size);
+ length_of_vendor = INT16(length_of_vendor);
+ INT16(maximum_request_length);
+ number_of_screens_in_roots = INT8(number_of_screens_in_roots);
+ number_of_formats_in_pixmap_formats = INT8(number_of_formats_in_pixmap_formats);
+ INT8(image_byte_order);
+ INT8(bitmap_format_bit_order);
+ INT8(bitmap_format_scanline_unit);
+ INT8(bitmap_format_scanline_pad);
+ INT8(min_keycode);
+ INT8(max_keycode);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 4, ENC_NA);
+ *offsetp += 4;
+ STRING8(vendor, length_of_vendor);
+ unused = (4 - (length_of_vendor % 4)) % 4;
+ if (unused > 0) {
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, unused, ENC_NA);
+ *offsetp += unused;
+ }
+ LISTofPIXMAPFORMAT(pixmap_format, number_of_formats_in_pixmap_formats);
+ LISTofSCREEN(screen, number_of_screens_in_roots);
+ } else {
+ STRING8(reason, length_of_reason);
+ }
+
+ if ((left = tvb_reported_length_remaining(tvb, offset)) > 0)
+ UNDECODED(left);
+
+}
+
+typedef struct x11_reply_info {
+ const guint8 minor;
+ void (*dissect)(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, guint byte_order);
+} x11_reply_info;
+
+typedef struct event_info {
+ const gchar *name;
+ void (*dissect)(tvbuff_t *tvb, int *offsetp, proto_tree *t, guint byte_order);
+} x11_event_info;
+
+typedef struct x11_generic_event_info {
+ const guint16 minor;
+ void (*dissect)(tvbuff_t *tvb, int length, int *offsetp, proto_tree *t, guint byte_order);
+} x11_generic_event_info;
+
+static void set_handler(const char *name, void (*func)(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, guint byte_order),
+ const char **errors,
+ const x11_event_info *event_info,
+ const x11_generic_event_info *genevent_info,
+ const x11_reply_info *reply_info)
+{
+ wmem_map_insert(extension_table, (gpointer)name, (gpointer)func);
+ wmem_map_insert(error_table, (gpointer)name, (gpointer)errors);
+ wmem_map_insert(event_table, (gpointer)name, (gpointer)event_info);
+ if (genevent_info)
+ wmem_map_insert(genevent_table, (gpointer)name, (gpointer)genevent_info);
+ wmem_map_insert(reply_table, (gpointer)name, (gpointer)reply_info);
+}
+
+#include "x11-extension-errors.h"
+#include "x11-extension-implementation.h"
+
+static void tryExtension(int opcode, tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t,
+ x11_conv_data_t *state, guint byte_order)
+{
+ const gchar *extension;
+ void (*func)(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, guint byte_order);
+
+ extension = try_val_to_str(opcode, state->opcode_vals);
+ if (!extension)
+ return;
+
+ func = (void (*)(tvbuff_t *, packet_info *, int *, proto_tree *, guint))wmem_map_lookup(extension_table, extension);
+ if (func)
+ func(tvb, pinfo, offsetp, t, byte_order);
+}
+
+static void tryExtensionReply(int opcode, tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t,
+ x11_conv_data_t *state, guint byte_order)
+{
+ void (*func)(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, guint byte_order);
+
+ func = (void (*)(tvbuff_t *, packet_info *, int *, proto_tree *, guint))wmem_map_lookup(state->reply_funcs, GINT_TO_POINTER(opcode));
+ if (func)
+ func(tvb, pinfo, offsetp, t, byte_order);
+ else
+ REPLYCONTENTS_COMMON();
+}
+
+static void tryExtensionEvent(int event, tvbuff_t *tvb, int *offsetp, proto_tree *t,
+ x11_conv_data_t *state, guint byte_order)
+{
+ void (*func)(tvbuff_t *tvb, int *offsetp, proto_tree *t, guint byte_order);
+
+ func = (void (*)(tvbuff_t *, int *, proto_tree *, guint))wmem_map_lookup(state->eventcode_funcs, GINT_TO_POINTER(event));
+ if (func)
+ func(tvb, offsetp, t, byte_order);
+}
+
+static void tryGenericExtensionEvent(tvbuff_t *tvb, int *offsetp, proto_tree *t,
+ x11_conv_data_t *state, guint byte_order)
+{
+ const gchar *extname;
+ int extension, length;
+
+ extension = tvb_get_guint8(tvb, *offsetp);
+ (*offsetp)++;
+ extname = try_val_to_str(extension, state->opcode_vals);
+
+ if (extname) {
+ proto_tree_add_uint_format(t, hf_x11_extension, tvb, *offsetp, 1, extension, "extension: %d (%s)", extension, extname);
+ } else {
+ proto_tree_add_uint(t, hf_x11_extension, tvb, *offsetp, 1, extension);
+ }
+
+ CARD16(event_sequencenumber);
+
+ length = REPLYLENGTH(eventlength);
+ length = length * 4 + 32;
+ *offsetp += 4;
+
+ if (extname) {
+ x11_generic_event_info *info;
+ info = (x11_generic_event_info *)wmem_map_lookup(genevent_table, extname);
+
+ if (info) {
+ int i;
+
+ int opcode = tvb_get_guint16(tvb, *offsetp, byte_order);
+
+ for (i = 0; info[i].dissect != NULL; i++) {
+ if (info[i].minor == opcode) {
+ *offsetp += 2;
+ info[i].dissect(tvb, length, offsetp, t, byte_order);
+ return;
+ }
+ }
+ }
+ }
+ CARD16(minor_opcode);
+}
+
+static void register_extension(x11_conv_data_t *state, value_string *vals_p,
+ int major_opcode, unsigned int first_event, unsigned int first_error)
+{
+ const char **error_string;
+ x11_event_info *event_info;
+ x11_reply_info *reply_info;
+ int i;
+
+ vals_p->value = major_opcode;
+
+ error_string = (const char **)wmem_map_lookup(error_table, vals_p->strptr);
+ while (error_string && *error_string && first_error <= LastExtensionError) {
+ /* store string of extension error */
+ for (i = 0; i <= LastExtensionError; i++) {
+ if (state->errorcode_vals[i].strptr == NULL) {
+ state->errorcode_vals[i].value = first_error;
+ state->errorcode_vals[i].strptr = *error_string;
+ break;
+ } else if (state->errorcode_vals[i].value == first_error) {
+ /* TODO: Warn about extensions stepping on each other */
+ state->errorcode_vals[i].strptr = *error_string;
+ break;
+ }
+ }
+ first_error++;
+ error_string++;
+ }
+
+ event_info = (x11_event_info *)wmem_map_lookup(event_table, vals_p->strptr);
+ while (event_info && event_info->name && first_event <= LastExtensionEvent) {
+ /* store string of extension event */
+ for (i = 0; i <= LastExtensionEvent; i++) {
+ if (state->eventcode_vals[i].strptr == NULL) {
+ state->eventcode_vals[i].value = first_event;
+ state->eventcode_vals[i].strptr = event_info->name;
+ break;
+ } else if (state->eventcode_vals[i].value == first_event) {
+ /* TODO: Warn about extensions stepping on each other */
+ state->eventcode_vals[i].strptr = event_info->name;
+ break;
+ }
+ }
+
+ /* store event decode function */
+ wmem_map_insert(state->eventcode_funcs, GINT_TO_POINTER(first_event), (gpointer)event_info->dissect);
+
+ first_event++;
+ event_info++;
+ }
+
+ reply_info = (x11_reply_info *)wmem_map_lookup(reply_table, vals_p->strptr);
+ if (reply_info)
+ for (i = 0; reply_info[i].dissect; i++)
+ wmem_map_insert(state->reply_funcs,
+ GINT_TO_POINTER(major_opcode | (reply_info[i].minor << 8)),
+ (gpointer)reply_info[i].dissect);
+}
+
+
+static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo,
+ proto_tree *tree, const char *sep, x11_conv_data_t *state,
+ guint byte_order)
+{
+ int offset = 0;
+ int *offsetp = &offset;
+ int query_ext_offset;
+ int next_offset;
+ proto_item *ti;
+ proto_tree *t;
+ int length, opcode, i;
+ guint8 v8, v8_2, v8_3;
+ guint16 v16;
+ guint32 v32;
+ gint left;
+ gchar *name;
+
+ query_ext_offset = 2; /* "opcode" and "unused" */
+
+ length = tvb_get_guint16(tvb, query_ext_offset, byte_order) * 4;
+ query_ext_offset += 2;
+
+ if (length == 0) {
+ /* BIG-REQUESTS extension */
+ length = tvb_get_guint32(tvb, query_ext_offset, byte_order);
+ if ((gint64)length * 4 > G_MAXINT32)
+ return;
+ length *= 4;
+ query_ext_offset += 4;
+ }
+
+ if (length < 4) {
+ /* Bogus message length? */
+ return;
+ }
+
+ next_offset = offset + length;
+
+ ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
+ t = proto_item_add_subtree(ti, ett_x11);
+
+ if (!pinfo->fd->visited)
+ ++state->sequencenumber;
+
+ OPCODE();
+
+ col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s", sep,
+ val_to_str(opcode, state->opcode_vals,
+ "<Unknown opcode %d>"));
+
+ proto_item_append_text(ti, ", Request, opcode: %d (%s)",
+ opcode, val_to_str(opcode, state->opcode_vals,
+ "<Unknown opcode %d>"));
+
+ /*
+ * Does this request expect a reply?
+ */
+ switch(opcode) {
+
+ case X_QueryExtension:
+
+ /* necessary processing even if tree == NULL */
+
+ v16 = tvb_get_guint16(tvb, query_ext_offset, byte_order);
+ query_ext_offset += 2;
+ /* Some unused bytes */
+ query_ext_offset += 2;
+ name = tvb_get_string_enc(wmem_file_scope(), tvb, query_ext_offset, v16, ENC_ASCII);
+
+ /* store string of extension, opcode will be set at reply */
+ i = 0;
+ while(i < MAX_OPCODES) {
+ if (state->opcode_vals[i].strptr == NULL) {
+ state->opcode_vals[i].strptr = name;
+ state->opcode_vals[i].value = -1;
+ wmem_map_insert(state->valtable,
+ GINT_TO_POINTER(state->sequencenumber),
+ (int *)&state->opcode_vals[i]);
+ break;
+ } else if (strcmp(state->opcode_vals[i].strptr,
+ name) == 0) {
+ wmem_map_insert(state->valtable,
+ GINT_TO_POINTER(state->sequencenumber),
+ (int *)&state->opcode_vals[i]);
+ break;
+ }
+ i++;
+ }
+
+ /* QueryExtension expects a reply, fall through */
+ /* FALLTHROUGH */
+ case X_AllocColor:
+ case X_AllocColorCells:
+ case X_AllocColorPlanes:
+ case X_AllocNamedColor:
+ case X_GetAtomName:
+ case X_GetFontPath:
+ case X_GetGeometry:
+ case X_GetImage:
+ case X_GetInputFocus:
+ case X_GetKeyboardControl:
+ case X_GetKeyboardMapping:
+ case X_GetModifierMapping:
+ case X_GetMotionEvents:
+ case X_GetPointerControl:
+ case X_GetPointerMapping:
+ case X_GetProperty:
+ case X_GetScreenSaver:
+ case X_GetSelectionOwner:
+ case X_GetWindowAttributes:
+ case X_GrabKeyboard:
+ case X_GrabPointer:
+ case X_InternAtom:
+ case X_ListExtensions:
+ case X_ListFonts:
+ case X_ListFontsWithInfo:
+ case X_ListHosts:
+ case X_ListInstalledColormaps:
+ case X_ListProperties:
+ case X_LookupColor:
+ case X_QueryBestSize:
+ case X_QueryColors:
+ case X_QueryFont:
+ case X_QueryKeymap:
+ case X_QueryPointer:
+ case X_QueryTextExtents:
+ case X_QueryTree:
+ case X_SetModifierMapping:
+ case X_SetPointerMapping:
+ case X_TranslateCoords:
+ /*
+ * Those requests expect a reply.
+ */
+ wmem_map_insert(state->seqtable,
+ GINT_TO_POINTER(state->sequencenumber),
+ GINT_TO_POINTER(opcode));
+
+ break;
+
+ default:
+ /*
+ * With Extension, we don't know, so assume there could be one
+ */
+ if (opcode >= X_FirstExtension && opcode <= X_LastExtension) {
+ guint32 minor;
+ minor = tvb_get_guint8(tvb, 1);
+
+ wmem_map_insert(state->seqtable,
+ GINT_TO_POINTER(state->sequencenumber),
+ GINT_TO_POINTER(opcode | (minor << 8)));
+ }
+
+ /*
+ * No reply is expected from any other request.
+ */
+ break;
+ }
+
+ if (tree == NULL)
+ return;
+
+ switch(opcode) {
+
+ case X_CreateWindow:
+ CARD8(depth);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(wid);
+ WINDOW(parent);
+ INT16(x);
+ INT16(y);
+ CARD16(width);
+ CARD16(height);
+ CARD16(border_width);
+ ENUM16(window_class);
+ VISUALID(visual);
+ windowAttributes(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_ChangeWindowAttributes:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ windowAttributes(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_GetWindowAttributes:
+ case X_DestroyWindow:
+ case X_DestroySubwindows:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ break;
+
+ case X_ChangeSaveSet:
+ ENUM8(save_set_mode);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ break;
+
+ case X_ReparentWindow:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ WINDOW(parent);
+ INT16(x);
+ INT16(y);
+ break;
+
+ case X_MapWindow:
+ case X_MapSubwindows:
+ case X_UnmapWindow:
+ case X_UnmapSubwindows:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ break;
+
+ case X_ConfigureWindow:
+ {
+ guint16 bitmask16;
+ static int * const window_attributes_flags[] = {
+ &hf_x11_window_value_mask_background_pixmap,
+ &hf_x11_window_value_mask_background_pixel,
+ &hf_x11_window_value_mask_border_pixmap,
+ &hf_x11_window_value_mask_border_pixel,
+ &hf_x11_window_value_mask_bit_gravity,
+ &hf_x11_window_value_mask_win_gravity,
+ &hf_x11_window_value_mask_backing_store,
+ &hf_x11_window_value_mask_backing_planes,
+ &hf_x11_window_value_mask_backing_pixel,
+ &hf_x11_window_value_mask_override_redirect,
+ &hf_x11_window_value_mask_save_under,
+ &hf_x11_window_value_mask_event_mask,
+ &hf_x11_window_value_mask_do_not_propagate_mask,
+ &hf_x11_window_value_mask_colormap,
+ &hf_x11_window_value_mask_cursor,
+ NULL
+ };
+
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ proto_tree_add_item(t, hf_x11_window, tvb, *offsetp, 1, byte_order);
+ *offsetp += 4;
+ bitmask16 = tvb_get_guint16(tvb, *offsetp, byte_order);
+ proto_tree_add_bitmask(t, tvb, *offsetp, hf_x11_configure_window_mask, ett_x11_configure_window_mask, window_attributes_flags, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ if (bitmask16 & 0x0001) {
+ proto_tree_add_item(t, hf_x11_x, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask16 & 0x0002) {
+ proto_tree_add_item(t, hf_x11_y, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask16 & 0x0004) {
+ proto_tree_add_item(t, hf_x11_width, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask16 & 0x0008) {
+ proto_tree_add_item(t, hf_x11_height, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask16 & 0x0010) {
+ proto_tree_add_item(t, hf_x11_border_width, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask16 & 0x0020) {
+ proto_tree_add_item(t, hf_x11_sibling, tvb, *offsetp, 4, byte_order);
+ *offsetp += 4;
+ }
+ if (bitmask16 & 0x0040) {
+ proto_tree_add_item(t, hf_x11_stack_mode, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (next_offset - *offsetp > 0) {
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, next_offset - *offsetp, ENC_NA);
+ *offsetp = next_offset;
+ }
+ }
+ break;
+
+ case X_CirculateWindow:
+ ENUM8(direction);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ break;
+
+ case X_GetGeometry:
+ case X_QueryTree:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ break;
+
+ case X_InternAtom:
+ BOOL(only_if_exists);
+ requestLength(tvb, offsetp, t, byte_order);
+ v16 = FIELD16(name_length);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ STRING8(name, v16);
+ PAD();
+ break;
+
+ case X_GetAtomName:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ ATOM(atom);
+ break;
+
+ case X_ChangeProperty:
+ ENUM8(mode);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ ATOM(property);
+ ATOM(type);
+ v8 = CARD8(format);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ v32 = CARD32(data_length);
+ switch (v8) {
+ case 8:
+ if (v32)
+ LISTofBYTE(data, v32);
+ break;
+ case 16:
+ if (v32)
+ LISTofCARD16(data16, v32 * 2);
+ break;
+ case 32:
+ if (v32)
+ LISTofCARD32(data32, v32 * 4);
+ break;
+ default:
+ expert_add_info(pinfo, ti, &ei_x11_invalid_format);
+ break;
+ }
+ PAD();
+ break;
+
+ case X_DeleteProperty:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ ATOM(property);
+ break;
+
+ case X_GetProperty:
+ BOOL(delete);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ ATOM(property);
+ ATOM(get_property_type);
+ CARD32(long_offset);
+ CARD32(long_length);
+ break;
+
+ case X_ListProperties:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ break;
+
+ case X_SetSelectionOwner:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(owner);
+ ATOM(selection);
+ TIMESTAMP(time);
+ break;
+
+ case X_GetSelectionOwner:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ ATOM(selection);
+ break;
+
+ case X_ConvertSelection:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(requestor);
+ ATOM(selection);
+ ATOM(target);
+ ATOM(property);
+ TIMESTAMP(time);
+ break;
+
+ case X_SendEvent:
+ BOOL(propagate);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(destination);
+ SETofEVENT(event_mask);
+ EVENT();
+ break;
+
+ case X_GrabPointer:
+ BOOL(owner_events);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(grab_window);
+ SETofPOINTEREVENT(pointer_event_mask);
+ ENUM8(pointer_mode);
+ ENUM8(keyboard_mode);
+ WINDOW(confine_to);
+ CURSOR(cursor);
+ TIMESTAMP(time);
+ break;
+
+ case X_UngrabPointer:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ TIMESTAMP(time);
+ break;
+
+ case X_GrabButton:
+ BOOL(owner_events);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(grab_window);
+ SETofPOINTEREVENT(event_mask);
+ ENUM8(pointer_mode);
+ ENUM8(keyboard_mode);
+ WINDOW(confine_to);
+ CURSOR(cursor);
+ BUTTON(button);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ SETofKEYMASK(modifiers);
+ break;
+
+ case X_UngrabButton:
+ BUTTON(button);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(grab_window);
+ SETofKEYMASK(modifiers);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ break;
+
+ case X_ChangeActivePointerGrab:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ CURSOR(cursor);
+ TIMESTAMP(time);
+ SETofPOINTEREVENT(event_mask);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ break;
+
+ case X_GrabKeyboard:
+ BOOL(owner_events);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(grab_window);
+ TIMESTAMP(time);
+ ENUM8(pointer_mode);
+ ENUM8(keyboard_mode);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ break;
+
+ case X_UngrabKeyboard:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ TIMESTAMP(time);
+ break;
+
+ case X_GrabKey:
+ BOOL(owner_events);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(grab_window);
+ SETofKEYMASK(modifiers);
+ KEYCODE(key);
+ ENUM8(pointer_mode);
+ ENUM8(keyboard_mode);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ break;
+
+ case X_UngrabKey:
+ KEYCODE(key);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(grab_window);
+ SETofKEYMASK(modifiers);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ break;
+
+ case X_AllowEvents:
+ ENUM8(allow_events_mode);
+ requestLength(tvb, offsetp, t, byte_order);
+ TIMESTAMP(time);
+ break;
+
+ case X_GrabServer:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_UngrabServer:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_QueryPointer:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ break;
+
+ case X_GetMotionEvents:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ TIMESTAMP(start);
+ TIMESTAMP(stop);
+ break;
+
+ case X_TranslateCoords:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(src_window);
+ WINDOW(dst_window);
+ INT16(src_x);
+ INT16(src_y);
+ break;
+
+ case X_WarpPointer:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(warp_pointer_src_window);
+ WINDOW(warp_pointer_dst_window);
+ INT16(src_x);
+ INT16(src_y);
+ CARD16(src_width);
+ CARD16(src_height);
+ INT16(dst_x);
+ INT16(dst_y);
+ break;
+
+ case X_SetInputFocus:
+ ENUM8(revert_to);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(focus);
+ TIMESTAMP(time);
+ break;
+
+ case X_GetInputFocus:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_QueryKeymap:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_OpenFont:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ FONT(fid);
+ v16 = FIELD16(name_length);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ STRING8(name, v16);
+ PAD();
+ break;
+
+ case X_CloseFont:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ FONT(font);
+ break;
+
+ case X_QueryFont:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ FONTABLE(font);
+ break;
+
+ case X_QueryTextExtents:
+ v8 = BOOL(odd_length);
+ requestLength(tvb, offsetp, t, byte_order);
+ FONTABLE(font);
+ STRING16(string16, (next_offset - offset - (v8 ? 2 : 0)) / 2);
+ PAD();
+ break;
+
+ case X_ListFonts:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ CARD16(max_names);
+ v16 = FIELD16(pattern_length);
+ STRING8(pattern, v16);
+ PAD();
+ break;
+
+ case X_ListFontsWithInfo:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ CARD16(max_names);
+ v16 = FIELD16(pattern_length);
+ STRING8(pattern, v16);
+ PAD();
+ break;
+
+ case X_SetFontPath:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ v16 = CARD16(str_number_in_path);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ LISTofSTRING8(path, v16);
+ PAD();
+ break;
+
+ case X_GetFontPath:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_CreatePixmap:
+ CARD8(depth);
+ requestLength(tvb, offsetp, t, byte_order);
+ PIXMAP(pid);
+ DRAWABLE(drawable);
+ CARD16(width);
+ CARD16(height);
+ break;
+
+ case X_FreePixmap:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ PIXMAP(pixmap);
+ break;
+
+ case X_CreateGC:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ GCONTEXT(cid);
+ DRAWABLE(drawable);
+ gcAttributes(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_ChangeGC:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ GCONTEXT(gc);
+ gcAttributes(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_CopyGC:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ GCONTEXT(src_gc);
+ GCONTEXT(dst_gc);
+ gcMask(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_SetDashes:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ GCONTEXT(gc);
+ CARD16(dash_offset);
+ v16 = FIELD16(dashes_length);
+ LISTofCARD8(dashes, v16);
+ PAD();
+ break;
+
+ case X_SetClipRectangles:
+ ENUM8(ordering);
+ requestLength(tvb, offsetp, t, byte_order);
+ GCONTEXT(gc);
+ INT16(clip_x_origin);
+ INT16(clip_y_origin);
+ LISTofRECTANGLE(rectangles);
+ break;
+
+ case X_FreeGC:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ GCONTEXT(gc);
+ break;
+
+ case X_ClearArea:
+ BOOL(exposures);
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ INT16(x);
+ INT16(y);
+ CARD16(width);
+ CARD16(height);
+ break;
+
+ case X_CopyArea:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(src_drawable);
+ DRAWABLE(dst_drawable);
+ GCONTEXT(gc);
+ INT16(src_x);
+ INT16(src_y);
+ INT16(dst_x);
+ INT16(dst_y);
+ CARD16(width);
+ CARD16(height);
+ break;
+
+ case X_CopyPlane:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(src_drawable);
+ DRAWABLE(dst_drawable);
+ GCONTEXT(gc);
+ INT16(src_x);
+ INT16(src_y);
+ INT16(dst_x);
+ INT16(dst_y);
+ CARD16(width);
+ CARD16(height);
+ CARD32(bit_plane);
+ break;
+
+ case X_PolyPoint:
+ ENUM8(coordinate_mode);
+ v16 = requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ LISTofPOINT(points, v16 - 12);
+ break;
+
+ case X_PolyLine:
+ ENUM8(coordinate_mode);
+ v16 = requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ LISTofPOINT(points, v16 - 12);
+ break;
+
+ case X_PolySegment:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ LISTofSEGMENT(segments);
+ break;
+
+ case X_PolyRectangle:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ LISTofRECTANGLE(rectangles);
+ break;
+
+ case X_PolyArc:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ LISTofARC(arcs);
+ break;
+
+ case X_FillPoly:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ v16 = requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ ENUM8(shape);
+ ENUM8(coordinate_mode);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ LISTofPOINT(points, v16 - 16);
+ break;
+
+ case X_PolyFillRectangle:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ LISTofRECTANGLE(rectangles);
+ break;
+
+ case X_PolyFillArc:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ LISTofARC(arcs);
+ break;
+
+ case X_PutImage:
+ ENUM8(image_format);
+ v16 = requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ CARD16(width);
+ CARD16(height);
+ INT16(dst_x);
+ INT16(dst_y);
+ CARD8(left_pad);
+ CARD8(depth);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ LISTofBYTE(data, v16 - 24);
+ PAD();
+ break;
+
+ case X_GetImage:
+ ENUM8(image_pixmap_format);
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ INT16(x);
+ INT16(y);
+ CARD16(width);
+ CARD16(height);
+ CARD32(plane_mask);
+ break;
+
+ case X_PolyText8:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ INT16(x);
+ INT16(y);
+ LISTofTEXTITEM8(items);
+ PAD();
+ break;
+
+ case X_PolyText16:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ INT16(x);
+ INT16(y);
+ LISTofTEXTITEM16(items);
+ PAD();
+ break;
+
+ case X_ImageText8:
+ v8 = FIELD8(string_length);
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ INT16(x);
+ INT16(y);
+ STRING8(string, v8);
+ PAD();
+ break;
+
+ case X_ImageText16:
+ v8 = FIELD8(string_length);
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ GCONTEXT(gc);
+ INT16(x);
+ INT16(y);
+ STRING16(string16, v8);
+ PAD();
+ break;
+
+ case X_CreateColormap:
+ ENUM8(alloc);
+ requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(mid);
+ WINDOW(window);
+ VISUALID(visual);
+ break;
+
+ case X_FreeColormap:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(cmap);
+ break;
+
+ case X_CopyColormapAndFree:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(mid);
+ COLORMAP(src_cmap);
+ break;
+
+ case X_InstallColormap:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(cmap);
+ break;
+
+ case X_UninstallColormap:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(cmap);
+ break;
+
+ case X_ListInstalledColormaps:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ break;
+
+ case X_AllocColor:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(cmap);
+ CARD16(red);
+ CARD16(green);
+ CARD16(blue);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ break;
+
+ case X_AllocNamedColor:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(cmap);
+ v16 = FIELD16(name_length);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ STRING8(name, v16);
+ PAD();
+ break;
+
+ case X_AllocColorCells:
+ BOOL(contiguous);
+ requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(cmap);
+ CARD16(colors);
+ CARD16(planes);
+ break;
+
+ case X_AllocColorPlanes:
+ BOOL(contiguous);
+ requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(cmap);
+ CARD16(colors);
+ CARD16(reds);
+ CARD16(greens);
+ CARD16(blues);
+ break;
+
+ case X_FreeColors:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ v16 = requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(cmap);
+ CARD32(plane_mask);
+ LISTofCARD32(pixels, v16 - 12);
+ break;
+
+ case X_StoreColors:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ v16 = requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(cmap);
+ LISTofCOLORITEM(color_items, v16 - 8);
+ break;
+
+ case X_StoreNamedColor:
+ COLOR_FLAGS(color);
+ requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(cmap);
+ CARD32(pixel);
+ v16 = FIELD16(name_length);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ STRING8(name, v16);
+ PAD();
+ break;
+
+ case X_QueryColors:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ v16 = requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(cmap);
+ LISTofCARD32(pixels, v16 - 8);
+ break;
+
+ case X_LookupColor:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ COLORMAP(cmap);
+ v16 = FIELD16(name_length);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ STRING8(name, v16);
+ PAD();
+ break;
+
+ case X_CreateCursor:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ CURSOR(cid);
+ PIXMAP(source_pixmap);
+ PIXMAP(mask);
+ CARD16(fore_red);
+ CARD16(fore_green);
+ CARD16(fore_blue);
+ CARD16(back_red);
+ CARD16(back_green);
+ CARD16(back_blue);
+ CARD16(x);
+ CARD16(y);
+ break;
+
+ case X_CreateGlyphCursor:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ CURSOR(cid);
+ FONT(source_font);
+ FONT(mask_font);
+ CARD16(source_char);
+ CARD16(mask_char);
+ CARD16(fore_red);
+ CARD16(fore_green);
+ CARD16(fore_blue);
+ CARD16(back_red);
+ CARD16(back_green);
+ CARD16(back_blue);
+ break;
+
+ case X_FreeCursor:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ CURSOR(cursor);
+ break;
+
+ case X_RecolorCursor:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ CURSOR(cursor);
+ CARD16(fore_red);
+ CARD16(fore_green);
+ CARD16(fore_blue);
+ CARD16(back_red);
+ CARD16(back_green);
+ CARD16(back_blue);
+ break;
+
+ case X_QueryBestSize:
+ ENUM8(class);
+ requestLength(tvb, offsetp, t, byte_order);
+ DRAWABLE(drawable);
+ CARD16(width);
+ CARD16(height);
+ break;
+
+ case X_QueryExtension:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ v16 = FIELD16(name_length);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ STRING8(name, v16);
+ PAD();
+ break;
+
+ case X_ListExtensions:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_ChangeKeyboardMapping:
+ v8 = FIELD8(keycode_count);
+ requestLength(tvb, offsetp, t, byte_order);
+ v8_2 = KEYCODE(first_keycode);
+ v8_3 = FIELD8(keysyms_per_keycode);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ LISTofKEYSYM(keysyms, state->keycodemap, v8_2, v8, v8_3);
+ break;
+
+ case X_GetKeyboardMapping:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ state->request.GetKeyboardMapping.first_keycode
+ = KEYCODE(first_keycode);
+ FIELD8(count);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ break;
+
+ case X_ChangeKeyboardControl:
+ {
+ guint32 bitmask32;
+ static int * const keyboard_value_flags[] = {
+ &hf_x11_keyboard_value_mask_key_click_percent,
+ &hf_x11_keyboard_value_mask_bell_percent,
+ &hf_x11_keyboard_value_mask_bell_pitch,
+ &hf_x11_keyboard_value_mask_bell_duration,
+ &hf_x11_keyboard_value_mask_led,
+ &hf_x11_keyboard_value_mask_led_mode,
+ &hf_x11_keyboard_value_mask_keyboard_key,
+ &hf_x11_keyboard_value_mask_auto_repeat_mode,
+ NULL
+ };
+
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ bitmask32 = tvb_get_guint32(tvb, *offsetp, byte_order);
+ proto_tree_add_bitmask(t, tvb, *offsetp, hf_x11_keyboard_value_mask, ett_x11_keyboard_value_mask, keyboard_value_flags, byte_order);
+ *offsetp += 4;
+ if (bitmask32 & 0x00000001) {
+ proto_tree_add_item(t, hf_x11_key_click_percent, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask32 & 0x00000002) {
+ proto_tree_add_item(t, hf_x11_bell_percent, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask32 & 0x00000004) {
+ proto_tree_add_item(t, hf_x11_bell_pitch, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask32 & 0x00000008) {
+ proto_tree_add_item(t, hf_x11_bell_duration, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask32 & 0x00000010) {
+ proto_tree_add_item(t, hf_x11_led, tvb, *offsetp, 2, byte_order);
+ *offsetp += 2;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ }
+ if (bitmask32 & 0x00000020) {
+ proto_tree_add_item(t, hf_x11_led_mode, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask32 & 0x00000040) {
+ proto_tree_add_item(t, hf_x11_keyboard_key, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ if (bitmask32 & 0x00000080) {
+ proto_tree_add_item(t, hf_x11_auto_repeat_mode, tvb, *offsetp, 1, byte_order);
+ *offsetp += 1;
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 3, ENC_NA);
+ *offsetp += 3;
+ }
+ }
+ break;
+
+ case X_GetKeyboardControl:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_Bell:
+ INT8(percent);
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_ChangePointerControl:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ INT16(acceleration_numerator);
+ INT16(acceleration_denominator);
+ INT16(threshold);
+ BOOL(do_acceleration);
+ BOOL(do_threshold);
+ break;
+
+ case X_GetPointerControl:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_SetScreenSaver:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ INT16(timeout);
+ INT16(interval);
+ ENUM8(prefer_blanking);
+ ENUM8(allow_exposures);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ break;
+
+ case X_GetScreenSaver:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_ChangeHosts:
+ ENUM8(change_host_mode);
+ requestLength(tvb, offsetp, t, byte_order);
+ v8 = ENUM8(family);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ v16 = CARD16(address_length);
+ if (v8 == FAMILY_INTERNET && v16 == 4) {
+ /*
+ * IPv4 addresses.
+ * XXX - what about IPv6? Is that a family of
+ * FAMILY_INTERNET (0) with a length of 16?
+ */
+ LISTofIPADDRESS(ip_address, v16);
+ } else
+ LISTofCARD8(address, v16);
+ break;
+
+ case X_ListHosts:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_SetAccessControl:
+ ENUM8(access_mode);
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_SetCloseDownMode:
+ ENUM8(close_down_mode);
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_KillClient:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ CARD32(resource);
+ break;
+
+ case X_RotateProperties:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ v16 = requestLength(tvb, offsetp, t, byte_order);
+ WINDOW(window);
+ CARD16(property_number);
+ INT16(delta);
+ LISTofATOM(properties, (v16 - 12));
+ break;
+
+ case X_ForceScreenSaver:
+ ENUM8(screen_saver_mode);
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_SetPointerMapping:
+ v8 = FIELD8(map_length);
+ requestLength(tvb, offsetp, t, byte_order);
+ LISTofCARD8(map, v8);
+ PAD();
+ break;
+
+ case X_GetPointerMapping:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_SetModifierMapping:
+ v8 = FIELD8(keycodes_per_modifier);
+ requestLength(tvb, offsetp, t, byte_order);
+ LISTofKEYCODE(state->modifiermap, keycodes, v8);
+ break;
+
+ case X_GetModifierMapping:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+
+ case X_NoOperation:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ requestLength(tvb, offsetp, t, byte_order);
+ break;
+ default:
+ tryExtension(opcode, tvb, pinfo, offsetp, t, state, byte_order);
+ break;
+ }
+
+ if ((left = tvb_reported_length_remaining(tvb, offset)) > 0)
+ UNDECODED(left);
+}
+
+static void dissect_x11_requests(tvbuff_t *tvb, packet_info *pinfo,
+ proto_tree *tree)
+{
+ volatile int offset = 0;
+ int length_remaining;
+ volatile guint byte_order;
+ guint8 opcode;
+ volatile gint plen;
+ proto_item *ti;
+ volatile gboolean is_initial_creq;
+ guint16 auth_proto_len, auth_data_len;
+ const char *volatile sep = NULL;
+ conversation_t *conversation;
+ x11_conv_data_t *volatile state;
+ int length;
+ tvbuff_t *volatile next_tvb;
+
+ while ((length_remaining = tvb_reported_length_remaining(tvb, offset)) > 0) {
+
+ /*
+ * Can we do reassembly?
+ */
+ if (x11_desegment && pinfo->can_desegment) {
+ /*
+ * Yes - is the X11 request header split across
+ * segment boundaries?
+ */
+ if (length_remaining < 4) {
+ /*
+ * Yes. Tell the TCP dissector where the data
+ * for this message starts in the data it handed
+ * us and that we need "some more data." Don't tell
+ * it exactly how many bytes we need because if/when
+ * we ask for even more (after the header) that will
+ * break reassembly.
+ */
+ pinfo->desegment_offset = offset;
+ pinfo->desegment_len = DESEGMENT_ONE_MORE_SEGMENT;
+ return;
+ }
+ }
+
+ /*
+ * Get the state for this conversation; create the conversation
+ * if we don't have one, and create the state if we don't have
+ * any.
+ */
+ conversation = find_or_create_conversation(pinfo);
+
+ /*
+ * Is there state attached to this conversation?
+ */
+ if ((state = (x11_conv_data_t *)conversation_get_proto_data(conversation, proto_x11))
+ == NULL)
+ state = x11_stateinit(conversation);
+
+ /*
+ * Guess the byte order if we don't already know it.
+ */
+ byte_order = guess_byte_ordering(tvb, pinfo, state);
+
+ /*
+ * Get the opcode and length of the putative X11 request.
+ */
+ opcode = tvb_get_guint8(tvb, 0);
+ plen = tvb_get_guint16(tvb, offset + 2, byte_order);
+
+ if (plen == 0) {
+ /*
+ * A length field of 0 indicates that the BIG-REQUESTS
+ * extension is used: The next four bytes are the real length.
+ */
+ plen = tvb_get_guint32(tvb, offset + 4, byte_order);
+ }
+
+ if (plen <= 0) {
+ /*
+ * This can't be less then 0, as it includes the header length.
+ * A different choice of byte order wouldn't have
+ * helped.
+ * Give up.
+ */
+ ti = proto_tree_add_item(tree, proto_x11, tvb, offset, -1, ENC_NA);
+ expert_add_info_format(pinfo, ti, &ei_x11_request_length, "Bogus request length (%d)", plen);
+ return;
+ }
+
+ if (state->iconn_frame == pinfo->num ||
+ (wmem_map_lookup(state->seqtable,
+ GINT_TO_POINTER(state->sequencenumber)) == (int *)NOTHING_SEEN &&
+ (opcode == 'B' || opcode == 'l') &&
+ (plen == 11 || plen == 2816))) {
+ /*
+ * Either
+ *
+ * we saw this on the first pass and this is
+ * it again
+ *
+ * or
+ * we haven't already seen any requests, the first
+ * byte of the message is 'B' or 'l', and the 16-bit
+ * integer 2 bytes into the data stream is either 11
+ * or a byte-swapped 11.
+ *
+ * This means it's probably an initial connection
+ * request, not a message.
+ *
+ * 'B' is decimal 66, which is the opcode for a
+ * PolySegment request; unfortunately, 11 is a valid
+ * length for a PolySegment request request, so we
+ * might mis-identify that request. (Are there any
+ * other checks we can do?)
+ *
+ * 'l' is decimal 108, which is the opcode for a
+ * GetScreenSaver request; the only valid length
+ * for that request is 1.
+ */
+ is_initial_creq = TRUE;
+
+ /*
+ * We now know the byte order. Override the guess.
+ */
+ if (state->byte_order == BYTE_ORDER_UNKNOWN) {
+ if (opcode == 'B') {
+ /*
+ * Big-endian.
+ */
+ byte_order = state->byte_order = ENC_BIG_ENDIAN;
+ } else {
+ /*
+ * Little-endian.
+ */
+ byte_order = state->byte_order = ENC_LITTLE_ENDIAN;
+ }
+ }
+
+ /*
+ * Can we do reassembly?
+ */
+ if (x11_desegment && pinfo->can_desegment) {
+ /*
+ * Yes - is the fixed-length portion of the
+ * initial connection header split across
+ * segment boundaries?
+ */
+ if (length_remaining < 10) {
+ /*
+ * Yes. Tell the TCP dissector where the
+ * data for this message starts in the data
+ * it handed us and that we need "some more
+ * data." Don't tell it exactly how many bytes
+ * we need because if/when we ask for even more
+ * (after the header) that will break reassembly.
+ */
+ pinfo->desegment_offset = offset;
+ pinfo->desegment_len = DESEGMENT_ONE_MORE_SEGMENT;
+ return;
+ }
+ }
+
+ /*
+ * Get the lengths of the authorization protocol and
+ * the authorization data.
+ */
+ auth_proto_len = tvb_get_guint16(tvb, offset + 6, byte_order);
+ auth_data_len = tvb_get_guint16(tvb, offset + 8, byte_order);
+ plen = 12 + ROUND_LENGTH(auth_proto_len) +
+ ROUND_LENGTH(auth_data_len);
+ } else {
+ volatile gint64 tmp = (gint64)plen * 4;
+ /*
+ * This is probably an ordinary request.
+ */
+ is_initial_creq = FALSE;
+
+ /*
+ * The length of a request is in 4-byte words.
+ */
+ if (tmp > G_MAXINT32) {
+ ti = proto_tree_add_item(tree, proto_x11, tvb, offset, -1, ENC_NA);
+ expert_add_info_format(pinfo, ti, &ei_x11_request_length, "Bogus request length (%"PRId64")", tmp);
+ return;
+ }
+ plen = (gint)tmp;
+ }
+
+ /*
+ * Can we do reassembly?
+ */
+ if (x11_desegment && pinfo->can_desegment) {
+ /*
+ * Yes - is the X11 request split across segment
+ * boundaries?
+ */
+ if (length_remaining < plen) {
+ /*
+ * Yes. Tell the TCP dissector where the data
+ * for this message starts in the data it handed
+ * us, and how many more bytes we need, and return.
+ */
+ pinfo->desegment_offset = offset;
+ pinfo->desegment_len = plen - length_remaining;
+ return;
+ }
+ }
+
+ /*
+ * Construct a tvbuff containing the amount of the payload
+ * we have available. Make its reported length the
+ * amount of data in the X11 request.
+ *
+ * XXX - if reassembly isn't enabled. the subdissector
+ * will throw a BoundsError exception, rather than a
+ * ReportedBoundsError exception. We really want a tvbuff
+ * where the length is "length", the reported length is "plen",
+ * and the "if the snapshot length were infinite" length is the
+ * minimum of the reported length of the tvbuff handed to us
+ * and "plen", with a new type of exception thrown if the offset
+ * is within the reported length but beyond that third length,
+ * with that exception getting the "Unreassembled Packet" error.
+ */
+ length = length_remaining;
+ if (length > plen)
+ length = plen;
+ next_tvb = tvb_new_subset_length_caplen(tvb, offset, length, plen);
+
+ /*
+ * Set the column appropriately.
+ */
+ if (is_initial_creq) {
+ col_set_str(pinfo->cinfo, COL_INFO, "Initial connection request");
+ } else {
+ if (sep == NULL) {
+ /*
+ * We haven't set the column yet; set it.
+ */
+ col_set_str(pinfo->cinfo, COL_INFO, "Requests");
+
+ /*
+ * Initialize the separator.
+ */
+ sep = ":";
+ }
+ }
+
+ /*
+ * Dissect the X11 request.
+ *
+ * Catch the ReportedBoundsError exception; if this
+ * particular message happens to get a ReportedBoundsError
+ * exception, that doesn't mean that we should stop
+ * dissecting X11 requests within this frame or chunk of
+ * reassembled data.
+ *
+ * If it gets a BoundsError, we can stop, as there's nothing
+ * more to see, so we just re-throw it.
+ */
+ TRY {
+ if (is_initial_creq) {
+ dissect_x11_initial_conn(next_tvb, pinfo, tree,
+ state, byte_order);
+ } else {
+ dissect_x11_request(next_tvb, pinfo, tree, sep,
+ state, byte_order);
+ }
+ }
+ CATCH_NONFATAL_ERRORS {
+ show_exception(tvb, pinfo, tree, EXCEPT_CODE, GET_MESSAGE);
+ }
+ ENDTRY;
+
+ /*
+ * Skip the X11 message.
+ */
+ offset += plen;
+
+ sep = ",";
+ }
+}
+
+static x11_conv_data_t *
+x11_stateinit(conversation_t *conversation)
+{
+ x11_conv_data_t *state;
+ static x11_conv_data_t stateinit;
+ int i;
+
+ state = wmem_new(wmem_file_scope(), x11_conv_data_t);
+ *state = stateinit;
+
+ /* initialise opcodes */
+ for (i = 0; opcode_vals[i].strptr != NULL; i++) {
+ state->opcode_vals[i].value = opcode_vals[i].value;
+ state->opcode_vals[i].strptr = opcode_vals[i].strptr;
+ }
+ for (; i <= MAX_OPCODES; i++) {
+ state->opcode_vals[i].value = 0;
+ state->opcode_vals[i].strptr = NULL;
+ }
+
+ /* initialise errorcodes */
+ for (i = 0; errorcode_vals[i].strptr != NULL; i++) {
+ state->errorcode_vals[i].value = errorcode_vals[i].value;
+ state->errorcode_vals[i].strptr = errorcode_vals[i].strptr;
+ }
+ for (; i <= LastExtensionError + 1; i++) {
+ state->errorcode_vals[i].value = 0;
+ state->errorcode_vals[i].strptr = NULL;
+ }
+
+ /* initialise eventcodes */
+ for (i = 0; eventcode_vals[i].strptr != NULL; i++) {
+ state->eventcode_vals[i].value = eventcode_vals[i].value;
+ state->eventcode_vals[i].strptr = eventcode_vals[i].strptr;
+ }
+ for (; i <= LastExtensionEvent + 1; i++) {
+ state->eventcode_vals[i].value = 0;
+ state->eventcode_vals[i].strptr = NULL;
+ }
+ state->eventcode_funcs = wmem_map_new(wmem_file_scope(), g_direct_hash, g_direct_equal);
+ state->reply_funcs = wmem_map_new(wmem_file_scope(), g_direct_hash, g_direct_equal);
+
+ state->seqtable = wmem_map_new(wmem_file_scope(), g_direct_hash, g_direct_equal);
+ state->valtable = wmem_map_new(wmem_file_scope(), g_direct_hash, g_direct_equal);
+ wmem_map_insert(state->seqtable, (int *)0, (int *)NOTHING_SEEN);
+ state->byte_order = BYTE_ORDER_UNKNOWN; /* don't know yet*/
+ conversation_add_proto_data(conversation, proto_x11, state);
+ return state;
+}
+
+
+static void
+dissect_x11_replies(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+{
+/* Set up structures we will need to add the protocol subtree and manage it */
+ volatile int offset, plen;
+ tvbuff_t *volatile next_tvb;
+ conversation_t *conversation;
+ x11_conv_data_t *volatile state;
+ volatile guint byte_order;
+ int length_remaining;
+ const char *volatile sep = NULL;
+
+
+ /*
+ * Get the state for this conversation; create the conversation
+ * if we don't have one, and create the state if we don't have
+ * any.
+ */
+ conversation = find_or_create_conversation(pinfo);
+
+ /*
+ * Is there state attached to this conversation?
+ */
+ if ((state = (x11_conv_data_t *)conversation_get_proto_data(conversation, proto_x11))
+ == NULL) {
+ /*
+ * No - create a state structure and attach it.
+ */
+ state = x11_stateinit(conversation);
+ }
+
+ /*
+ * Guess the byte order if we don't already know it.
+ */
+ byte_order = guess_byte_ordering(tvb, pinfo, state);
+
+ offset = 0;
+ while ((length_remaining = tvb_reported_length_remaining(tvb, offset)) > 0) {
+ /*
+ * Can we do reassembly?
+ */
+ if (x11_desegment && pinfo->can_desegment) {
+ /*
+ * Yes - is the X11 Reply or GenericEvent header split across
+ * segment boundaries?
+ */
+ if (length_remaining < 8) {
+ /*
+ * Yes. Tell the TCP dissector where the data
+ * for this message starts in the data it handed
+ * us and that we need "some more data." Don't tell
+ * it exactly how many bytes we need because if/when
+ * we ask for even more (after the header) that will
+ * break reassembly.
+ */
+ pinfo->desegment_offset = offset;
+ pinfo->desegment_len = DESEGMENT_ONE_MORE_SEGMENT;
+ return;
+ }
+ }
+
+ /*
+ * Find out what kind of a reply it is.
+ * There are four possible:
+ * - reply to initial connection
+ * - errorreply (a request generated an error)
+ * - requestreply (reply to a request)
+ * - event (some event occurred)
+ */
+ if (wmem_map_lookup(state->seqtable,
+ GINT_TO_POINTER(state->sequencenumber)) == (int *)INITIAL_CONN
+ || (state->iconn_reply == pinfo->num)) {
+ /*
+ * Either the connection is in the "initial
+ * connection" state, or this frame is known
+ * to have the initial connection reply.
+ * That means this is the initial connection
+ * reply.
+ */
+ plen = 8 + tvb_get_guint16(tvb, offset + 6, byte_order) * 4;
+
+ HANDLE_REPLY(plen, length_remaining,
+ "Initial connection reply",
+ dissect_x11_initial_reply);
+ } else {
+ /*
+ * This isn't an initial connection reply
+ * (XXX - unless we missed the initial
+ * connection request). Look at the first
+ * byte to determine what it is; errors
+ * start with a byte of 0, replies start
+ * with a byte of 1, events start with
+ * a byte with of 2 or greater.
+ */
+ switch (tvb_get_guint8(tvb, offset)) {
+
+ case 0:
+ plen = 32;
+ HANDLE_REPLY(plen, length_remaining,
+ "Error", dissect_x11_error);
+ break;
+
+ case 1:
+ {
+ /* To avoid an "assert w/side-effect" warning,
+ * use a non-volatile temp variable instead. */
+ int tmp_plen;
+
+ /* replylength is in units of four. */
+ tmp_plen = plen = 32 + tvb_get_guint32(tvb, offset + 4, byte_order) * 4;
+ /* If tmp_plen < 32, we got an overflow;
+ * the reply length is too long. */
+ THROW_ON(tmp_plen < 32, ReportedBoundsError);
+ HANDLE_REPLY(plen, length_remaining,
+ "Reply", dissect_x11_reply);
+ break;
+ }
+
+ case GenericEvent:
+ {
+ /* An Event, but with a length field like a Reply. */
+
+ /* To avoid an "assert w/side-effect" warning,
+ * use a non-volatile temp variable instead. */
+ int tmp_plen;
+
+ /* GenericEvent's length is also in units of four. */
+ tmp_plen = plen = 32 + tvb_get_guint32(tvb, offset + 4, byte_order) * 4;
+ /* If tmp_plen < 32, we got an overflow;
+ * the event length is too long. */
+ THROW_ON(tmp_plen < 32, ReportedBoundsError);
+ HANDLE_REPLY(plen, length_remaining,
+ "Event", dissect_x11_event);
+ break;
+ }
+
+ default:
+ /* Event */
+ plen = 32;
+ HANDLE_REPLY(plen, length_remaining,
+ "Event", dissect_x11_event);
+ break;
+ }
+ }
+
+ offset += plen;
+ }
+
+ return;
+}
+
+static void
+dissect_x11_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+ const char *sep, x11_conv_data_t *state,
+ guint byte_order)
+{
+ int offset = 0, *offsetp = &offset, length, left, opcode;
+ int major_opcode, sequence_number, first_error, first_event;
+ value_string *vals_p;
+ proto_item *ti;
+ proto_tree *t;
+
+ ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
+ t = proto_item_add_subtree(ti, ett_x11);
+
+
+ /*
+ * XXX - this doesn't work correctly if either
+ *
+ * 1) the request sequence number wraps in the lower 16
+ * bits;
+ *
+ * 2) we don't see the initial connection request and the
+ * resynchronization of sequence number fails and thus
+ * don't have the right sequence numbers
+ *
+ * 3) we don't have all the packets in the capture and
+ * get out of sequence.
+ *
+ * We might, instead, want to assume that a reply is a reply to
+ * the most recent not-already-replied-to request in the same
+ * connection. That also might mismatch replies to requests if
+ * packets are lost, but there's nothing you can do to fix that.
+ */
+
+ sequence_number = tvb_get_guint16(tvb, offset + 2, byte_order);
+ opcode = GPOINTER_TO_INT(wmem_map_lookup(state->seqtable,
+ GINT_TO_POINTER(sequence_number)));
+
+ if (state->iconn_frame == 0 && state->resync == FALSE) {
+
+ /*
+ * We don't see the initial connection request and no
+ * resynchronization has been performed yet (first reply),
+ * set the current sequence number to the one of the
+ * current reply (this is only performed once).
+ */
+ state->sequencenumber = sequence_number;
+ state->resync = TRUE;
+ }
+
+ if (opcode == UNKNOWN_OPCODE) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,
+ "%s to unknown request", sep);
+ proto_item_append_text(ti, ", Reply to unknown request");
+ } else {
+ col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s",
+ sep,
+ val_to_str(opcode & 0xFF, state->opcode_vals,
+ "<Unknown opcode %d>"));
+
+ if (opcode > 0xFF)
+ proto_item_append_text(ti, ", Reply, opcode: %d.%d (%s)",
+ opcode & 0xFF, opcode >> 8, val_to_str(opcode & 0xFF,
+ state->opcode_vals,
+ "<Unknown opcode %d>"));
+ else
+ proto_item_append_text(ti, ", Reply, opcode: %d (%s)",
+ opcode, val_to_str(opcode,
+ state->opcode_vals,
+ "<Unknown opcode %d>"));
+ }
+
+ switch (opcode) {
+
+ /*
+ * Replies that need special processing outside tree
+ */
+
+ case X_QueryExtension:
+
+ /*
+ * if extension is present and request is known:
+ * store opcode of extension in value_string of
+ * opcodes
+ */
+ if (!tvb_get_guint8(tvb, offset + 8)) {
+ /* not present */
+ break;
+ }
+
+ vals_p = (value_string *)wmem_map_lookup(state->valtable,
+ GINT_TO_POINTER(sequence_number));
+ if (vals_p != NULL) {
+ major_opcode = tvb_get_guint8(tvb, offset + 9);
+ first_event = tvb_get_guint8(tvb, offset + 10);
+ first_error = tvb_get_guint8(tvb, offset + 11);
+
+ register_extension(state, vals_p, major_opcode, first_event, first_error);
+ wmem_map_remove(state->valtable,
+ GINT_TO_POINTER(sequence_number));
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ if (tree == NULL)
+ return;
+
+ switch (opcode) {
+ /*
+ * Requests that expect a reply.
+ */
+
+ case X_GetWindowAttributes:
+ REPLYCONTENTS_COMMON();
+ break;
+
+ case X_GetGeometry:
+ REPLY(reply);
+ CARD8(depth);
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ WINDOW(rootwindow);
+ INT16(x);
+ INT16(y);
+ CARD16(width);
+ CARD16(height);
+ CARD16(border_width);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 10, ENC_NA);
+ *offsetp += 10;
+ break;
+
+ case X_QueryTree:
+ REPLYCONTENTS_COMMON();
+ break;
+
+ case X_InternAtom:
+ REPLY(reply);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ ATOM(atom);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 20, ENC_NA);
+ *offsetp += 20;
+ break;
+
+ case X_GetAtomName:
+ REPLYCONTENTS_COMMON();
+ break;
+
+ case X_GetProperty:
+ REPLY(reply);
+ CARD8(format);
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ ATOM(get_property_type);
+ CARD32(bytes_after);
+ CARD32(valuelength);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 12, ENC_NA);
+ *offsetp += 12;
+ break;
+
+ case X_ListProperties:
+ REPLY(reply);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ length = CARD16(property_number);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 22, ENC_NA);
+ *offsetp += 22;
+ LISTofATOM(properties, length*4);
+ break;
+
+ case X_GetSelectionOwner:
+ REPLY(reply);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ WINDOW(owner);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 20, ENC_NA);
+ *offsetp += 20;
+ break;
+
+ case X_GrabPointer:
+ case X_GrabKeyboard:
+ REPLY(reply);
+ ENUM8(grab_status);
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 24, ENC_NA);
+ *offsetp += 24;
+ break;
+
+ case X_QueryPointer:
+ REPLY(reply);
+ BOOL(same_screen);
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ WINDOW(rootwindow);
+ WINDOW(childwindow);
+ INT16(root_x);
+ INT16(root_y);
+ INT16(win_x);
+ INT16(win_y);
+ SETofKEYBUTMASK(mask);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 6, ENC_NA);
+ *offsetp += 6;
+ break;
+
+ case X_GetMotionEvents:
+ REPLYCONTENTS_COMMON();
+ break;
+
+ case X_TranslateCoords:
+ REPLY(reply);
+ BOOL(same_screen);
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ WINDOW(childwindow);
+ INT16(dst_x);
+ INT16(dst_y);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 16, ENC_NA);
+ *offsetp += 16;
+ break;
+
+ case X_GetInputFocus:
+ REPLY(reply);
+ ENUM8(revert_to);
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ WINDOW(focus);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 20, ENC_NA);
+ *offsetp += 20;
+ break;
+
+ case X_QueryKeymap:
+ REPLY(reply);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ LISTofCARD8(keys, 32);
+ break;
+
+ case X_QueryFont:
+ case X_QueryTextExtents:
+ case X_ListFonts:
+ case X_GetImage:
+ case X_ListInstalledColormaps:
+ REPLYCONTENTS_COMMON();
+ break;
+
+ case X_AllocColor:
+ REPLY(reply);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ CARD16(red);
+ CARD16(green);
+ CARD16(blue);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 2, ENC_NA);
+ *offsetp += 2;
+ CARD32(pixel);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 12, ENC_NA);
+ *offsetp += 12;
+ break;
+
+ case X_QueryColors:
+ REPLYCONTENTS_COMMON();
+ break;
+
+ case X_LookupColor:
+ REPLY(reply);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ CARD16(exact_red);
+ CARD16(exact_green);
+ CARD16(exact_blue);
+ CARD16(visual_red);
+ CARD16(visual_green);
+ CARD16(visual_blue);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 12, ENC_NA);
+ *offsetp += 12;
+ break;
+
+ case X_QueryBestSize:
+ REPLY(reply);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ CARD16(width);
+ CARD16(height);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 20, ENC_NA);
+ *offsetp += 20;
+ break;
+
+ case X_QueryExtension:
+ REPLY(reply);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ BOOL(present);
+ CARD8(major_opcode);
+ CARD8(first_event);
+ CARD8(first_error);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 20, ENC_NA);
+ *offsetp += 20;
+ break;
+
+ case X_ListExtensions:
+ REPLYCONTENTS_COMMON();
+ break;
+
+ case X_GetKeyboardMapping:
+ state->first_keycode =
+ state->request.GetKeyboardMapping.first_keycode;
+ REPLY(reply);
+ state->keysyms_per_keycode =
+ FIELD8(keysyms_per_keycode);
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ length = REPLYLENGTH(replylength);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 24, ENC_NA);
+ *offsetp += 24;
+ LISTofKEYSYM(keysyms, state->keycodemap,
+ state->request.GetKeyboardMapping.first_keycode,
+ /* XXX - length / state->keysyms_per_keycode can raise a division by zero,
+ * don't know if this is the *right* way to fix it ... */
+ state->keysyms_per_keycode ? length / state->keysyms_per_keycode : 0,
+ state->keysyms_per_keycode);
+ break;
+
+ case X_GetKeyboardControl:
+ REPLYCONTENTS_COMMON();
+ break;
+
+ case X_GetPointerControl:
+ REPLY(reply);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ CARD16(acceleration_numerator);
+ CARD16(acceleration_denominator);
+ CARD16(threshold);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 18, ENC_NA);
+ *offsetp += 18;
+ break;
+
+ case X_GetScreenSaver:
+ REPLY(reply);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ CARD16(timeout);
+ CARD16(interval);
+ ENUM8(prefer_blanking);
+ ENUM8(allow_exposures);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 18, ENC_NA);
+ *offsetp += 18;
+ break;
+
+ case X_ListHosts:
+ case X_SetPointerMapping:
+ case X_GetPointerMapping:
+ case X_SetModifierMapping:
+ REPLYCONTENTS_COMMON();
+ break;
+
+ case X_GetModifierMapping:
+ REPLY(reply);
+ state->keycodes_per_modifier =
+ FIELD8(keycodes_per_modifier);
+ SEQUENCENUMBER_REPLY(sequencenumber);
+ REPLYLENGTH(replylength);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 24, ENC_NA);
+ *offsetp += 24;
+ LISTofKEYCODE(state->modifiermap, keycodes,
+ state->keycodes_per_modifier);
+ break;
+
+ case UNKNOWN_OPCODE:
+ REPLYCONTENTS_COMMON();
+ break;
+
+ default:
+ tryExtensionReply(opcode, tvb, pinfo, offsetp, t, state, byte_order);
+ }
+
+ if ((left = tvb_reported_length_remaining(tvb, offset)) > 0)
+ UNDECODED(left);
+}
+
+static void
+same_screen_focus(tvbuff_t *tvb, int *offsetp, proto_tree *t)
+{
+ proto_item *ti;
+ guint32 bitmask_value;
+ int bitmask_offset;
+ int bitmask_size;
+ proto_tree *bitmask_tree;
+
+ bitmask_value = tvb_get_guint8(tvb, *offsetp);
+ bitmask_offset = *offsetp;
+ bitmask_size = 1;
+
+ ti = proto_tree_add_uint(t, hf_x11_same_screen_focus_mask, tvb, *offsetp, 1,
+ bitmask_value);
+ bitmask_tree = proto_item_add_subtree(ti, ett_x11_same_screen_focus);
+ FLAG(same_screen_focus, focus);
+ FLAG(same_screen_focus, same_screen);
+
+ *offsetp += 1;
+}
+
+static void
+dissect_x11_event(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+ const char *sep, x11_conv_data_t *state,
+ guint byte_order)
+{
+ unsigned char eventcode;
+ const char *sent;
+ proto_item *ti;
+ proto_tree *t;
+
+ ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
+ t = proto_item_add_subtree(ti, ett_x11);
+
+ eventcode = tvb_get_guint8(tvb, 0);
+ sent = (eventcode & 0x80) ? "Sent-" : "";
+
+ col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s%s",
+ sep, sent,
+ val_to_str(eventcode & 0x7F, state->eventcode_vals,
+ "<Unknown eventcode %u>"));
+
+ proto_item_append_text(ti, ", Event, eventcode: %d (%s%s)",
+ eventcode, sent,
+ val_to_str(eventcode & 0x7F, state->eventcode_vals,
+ "<Unknown eventcode %u>"));
+
+ if (tree == NULL)
+ return;
+
+ decode_x11_event(tvb, eventcode, sent, t, state, byte_order);
+
+ return;
+}
+
+static void
+decode_x11_event(tvbuff_t *tvb, unsigned char eventcode, const char *sent,
+ proto_tree *t, x11_conv_data_t *state,
+ guint byte_order)
+{
+ int offset = 0, *offsetp = &offset, left;
+
+ proto_tree_add_uint_format(t, hf_x11_eventcode, tvb, offset, 1,
+ eventcode,
+ "eventcode: %d (%s%s)",
+ eventcode, sent,
+ val_to_str(eventcode & 0x7F, state->eventcode_vals,
+ "<Unknown eventcode %u>"));
+ ++offset;
+
+ switch (eventcode & 0x7F) {
+ case KeyPress:
+ case KeyRelease: {
+ int code, mask;
+
+ /* need to do some prefetching here ... */
+ code = tvb_get_guint8(tvb, offset);
+ mask = tvb_get_guint16(tvb, 28, byte_order);
+
+ KEYCODE_DECODED(keycode, code, mask);
+ CARD16(event_sequencenumber);
+ EVENTCONTENTS_COMMON();
+ BOOL(same_screen);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ break;
+ }
+
+ case ButtonPress:
+ case ButtonRelease:
+ BUTTON(eventbutton);
+ CARD16(event_sequencenumber);
+ EVENTCONTENTS_COMMON();
+ BOOL(same_screen);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ break;
+
+ case MotionNotify:
+ CARD8(detail);
+ CARD16(event_sequencenumber);
+ EVENTCONTENTS_COMMON();
+ BOOL(same_screen);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ break;
+
+ case EnterNotify:
+ case LeaveNotify:
+ ENUM8(event_detail);
+ CARD16(event_sequencenumber);
+ EVENTCONTENTS_COMMON();
+ ENUM8(grab_mode);
+ same_screen_focus(tvb, offsetp, t);
+ break;
+
+ case FocusIn:
+ case FocusOut:
+ ENUM8(focus_detail);
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ ENUM8(focus_mode);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 23, ENC_NA);
+ *offsetp += 23;
+ break;
+
+ case KeymapNotify:
+ break;
+
+ case Expose:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ INT16(x);
+ INT16(y);
+ CARD16(width);
+ CARD16(height);
+ CARD16(count);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 14, ENC_NA);
+ *offsetp += 14;
+ break;
+
+ case GraphicsExpose:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ DRAWABLE(drawable);
+ CARD16(x);
+ CARD16(y);
+ CARD16(width);
+ CARD16(height);
+ CARD16(minor_opcode);
+ CARD16(count);
+ CARD8(major_opcode);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 11, ENC_NA);
+ *offsetp += 11;
+ break;
+
+ case NoExpose:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ DRAWABLE(drawable);
+ CARD16(minor_opcode);
+ CARD8(major_opcode);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 21, ENC_NA);
+ *offsetp += 21;
+ break;
+
+ case VisibilityNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ ENUM8(visibility_state);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 23, ENC_NA);
+ *offsetp += 23;
+ break;
+
+ case CreateNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(parent);
+ WINDOW(eventwindow);
+ INT16(x);
+ INT16(y);
+ CARD16(width);
+ CARD16(height);
+ CARD16(border_width);
+ BOOL(override_redirect);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 9, ENC_NA);
+ *offsetp += 9;
+ break;
+
+ case DestroyNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ WINDOW(window);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 20, ENC_NA);
+ *offsetp += 20;
+ break;
+
+ case UnmapNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ WINDOW(window);
+ BOOL(from_configure);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 19, ENC_NA);
+ *offsetp += 19;
+ break;
+
+ case MapNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ WINDOW(window);
+ BOOL(override_redirect);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 19, ENC_NA);
+ *offsetp += 19;
+ break;
+
+ case MapRequest:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(parent);
+ WINDOW(eventwindow);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 20, ENC_NA);
+ *offsetp += 20;
+ break;
+
+ case ReparentNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ WINDOW(window);
+ WINDOW(parent);
+ INT16(x);
+ INT16(y);
+ BOOL(override_redirect);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 11, ENC_NA);
+ *offsetp += 11;
+ break;
+
+ case ConfigureNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ WINDOW(window);
+ WINDOW(above_sibling);
+ INT16(x);
+ INT16(y);
+ CARD16(width);
+ CARD16(height);
+ CARD16(border_width);
+ BOOL(override_redirect);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 5, ENC_NA);
+ *offsetp += 5;
+ break;
+
+ case ConfigureRequest:
+ break;
+
+ case GravityNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ WINDOW(window);
+ INT16(x);
+ INT16(y);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 16, ENC_NA);
+ *offsetp += 16;
+ break;
+
+ case ResizeRequest:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ CARD16(width);
+ CARD16(height);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 20, ENC_NA);
+ *offsetp += 20;
+ break;
+
+ case CirculateNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ WINDOW(window);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 4, ENC_NA);
+ *offsetp += 4;
+ ENUM8(place);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 15, ENC_NA);
+ *offsetp += 15;
+ break;
+
+ case CirculateRequest:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(parent);
+ WINDOW(eventwindow);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 4, ENC_NA);
+ *offsetp += 4;
+ ENUM8(place);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 15, ENC_NA);
+ *offsetp += 15;
+ break;
+
+ case PropertyNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ ATOM(atom);
+ TIMESTAMP(time);
+ ENUM8(property_state);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 15, ENC_NA);
+ *offsetp += 15;
+ break;
+
+ case SelectionClear:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ TIMESTAMP(time);
+ WINDOW(owner);
+ ATOM(selection);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 16, ENC_NA);
+ *offsetp += 16;
+ break;
+
+ case SelectionRequest:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ TIMESTAMP(time);
+ WINDOW(owner);
+ WINDOW(requestor);
+ ATOM(selection);
+ ATOM(target);
+ ATOM(property);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 4, ENC_NA);
+ *offsetp += 4;
+ break;
+
+ case SelectionNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ TIMESTAMP(time);
+ WINDOW(requestor);
+ ATOM(selection);
+ ATOM(target);
+ ATOM(property);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 8, ENC_NA);
+ *offsetp += 8;
+ break;
+
+ case ColormapNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ COLORMAP(cmap);
+ BOOL(new);
+ ENUM8(colormap_state);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 18, ENC_NA);
+ *offsetp += 18;
+ break;
+
+ case ClientMessage:
+ CARD8(format);
+ CARD16(event_sequencenumber);
+ WINDOW(eventwindow);
+ ATOM(type);
+ LISTofBYTE(data, 20);
+ break;
+
+ case MappingNotify:
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 1, ENC_NA);
+ *offsetp += 1;
+ CARD16(event_sequencenumber);
+ ENUM8(mapping_request);
+ CARD8(first_keycode);
+ CARD8(count);
+ proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, 25, ENC_NA);
+ *offsetp += 25;
+ break;
+
+ case GenericEvent:
+ tryGenericExtensionEvent(tvb, offsetp, t, state, byte_order);
+ break;
+
+ default:
+ tryExtensionEvent(eventcode & 0x7F, tvb, offsetp, t, state, byte_order);
+ break;
+ }
+
+ if ((left = tvb_reported_length_remaining(tvb, offset)) > 0)
+ UNDECODED(left);
+}
+
+static void
+dissect_x11_error(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+ const char *sep, x11_conv_data_t *state _U_,
+ guint byte_order)
+{
+ int offset = 0, *offsetp = &offset, left;
+ unsigned char errorcode;
+ proto_item *ti;
+ proto_tree *t;
+
+ ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
+ t = proto_item_add_subtree(ti, ett_x11);
+
+ CARD8(error);
+
+ errorcode = tvb_get_guint8(tvb, offset);
+ col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s",
+ sep, val_to_str(errorcode, state->errorcode_vals, "<Unknown errorcode %u>"));
+
+ proto_tree_add_uint_format(t, hf_x11_errorcode, tvb, offset, 1,
+ errorcode,
+ "errorcode: %d (%s)",
+ errorcode,
+ val_to_str(errorcode, state->errorcode_vals,
+ "<Unknown errorcode %u>"));
+ ++offset;
+
+ proto_item_append_text(ti, ", Error, errorcode: %d (%s)",
+ errorcode, val_to_str(errorcode, state->errorcode_vals,
+ "<Unknown errorcode %u>"));
+
+ if (tree == NULL)
+ return;
+
+ CARD16(error_sequencenumber);
+
+ switch (errorcode) {
+ case BadValue:
+ CARD32(error_badvalue);
+ break;
+ case BadWindow:
+ case BadPixmap:
+ case BadCursor:
+ case BadFont:
+ case BadDrawable:
+ case BadColormap:
+ case BadGC:
+ case BadIDChoice:
+ CARD32(error_badresourceid);
+ break;
+
+ default:
+ UNDECODED(4);
+ }
+
+ CARD16(minor_opcode);
+ CARD8(major_opcode);
+
+ if ((left = tvb_reported_length_remaining(tvb, offset)) > 0)
+ UNDECODED(left);
+}
+
+
+
+/************************************************************************
+ *** ***
+ *** I N I T I A L I Z A T I O N A N D M A I N ***
+ *** ***
+ ************************************************************************/
+
+static int
+dissect_x11(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+{
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, "X11");
+
+ if (pinfo->match_uint == pinfo->srcport)
+ dissect_x11_replies(tvb, pinfo, tree);
+ else
+ dissect_x11_requests(tvb, pinfo, tree);
+
+ return tvb_captured_length(tvb);
+}
+
+/* Register the protocol with Wireshark */
+void proto_register_x11(void)
+{
+
+/* Setup list of header fields */
+ static hf_register_info hf[] = {
+#include "x11-register-info.h"
+ };
+
+/* Setup protocol subtree array */
+ static gint *ett[] = {
+ &ett_x11,
+ &ett_x11_color_flags,
+ &ett_x11_list_of_arc,
+ &ett_x11_arc,
+ &ett_x11_list_of_atom,
+ &ett_x11_list_of_card32,
+ &ett_x11_list_of_float,
+ &ett_x11_list_of_double,
+ &ett_x11_list_of_color_item,
+ &ett_x11_color_item,
+ &ett_x11_list_of_keycode,
+ &ett_x11_list_of_keysyms,
+ &ett_x11_keysym,
+ &ett_x11_list_of_point,
+ &ett_x11_point,
+ &ett_x11_list_of_rectangle,
+ &ett_x11_rectangle,
+ &ett_x11_list_of_segment,
+ &ett_x11_segment,
+ &ett_x11_list_of_string8,
+ &ett_x11_list_of_text_item,
+ &ett_x11_text_item,
+ &ett_x11_gc_value_mask,
+ &ett_x11_event_mask,
+ &ett_x11_do_not_propagate_mask,
+ &ett_x11_set_of_key_mask,
+ &ett_x11_pointer_event_mask,
+ &ett_x11_window_value_mask,
+ &ett_x11_configure_window_mask,
+ &ett_x11_keyboard_value_mask,
+ &ett_x11_same_screen_focus,
+ &ett_x11_event,
+ &ett_x11_list_of_pixmap_format,
+ &ett_x11_pixmap_format,
+ &ett_x11_list_of_screen,
+ &ett_x11_screen,
+ &ett_x11_list_of_depth_detail,
+ &ett_x11_depth_detail,
+ &ett_x11_list_of_visualtype,
+ &ett_x11_visualtype,
+ };
+
+ static ei_register_info ei[] = {
+ { &ei_x11_invalid_format, { "x11.invalid_format", PI_PROTOCOL, PI_WARN, "Invalid Format", EXPFILL }},
+ { &ei_x11_request_length, { "x11.request-length.invalid", PI_PROTOCOL, PI_WARN, "Invalid Length", EXPFILL }},
+ { &ei_x11_keycode_value_out_of_range, { "x11.keycode_value_out_of_range", PI_PROTOCOL, PI_WARN, "keycode value is out of range", EXPFILL }},
+ };
+
+ module_t *x11_module;
+ expert_module_t* expert_x11;
+
+/* Register the protocol name and description */
+ proto_x11 = proto_register_protocol("X11", "X11", "x11");
+ x11_handle = register_dissector("x11", dissect_x11, proto_x11);
+
+/* Required function calls to register the header fields and subtrees used */
+ proto_register_field_array(proto_x11, hf, array_length(hf));
+ proto_register_subtree_array(ett, array_length(ett));
+ expert_x11 = expert_register_protocol(proto_x11);
+ expert_register_field_array(expert_x11, ei, array_length(ei));
+
+ extension_table = wmem_map_new(wmem_epan_scope(), wmem_str_hash, g_str_equal);
+ error_table = wmem_map_new(wmem_epan_scope(), wmem_str_hash, g_str_equal);
+ event_table = wmem_map_new(wmem_epan_scope(), wmem_str_hash, g_str_equal);
+ genevent_table = wmem_map_new(wmem_epan_scope(), wmem_str_hash, g_str_equal);
+ reply_table = wmem_map_new(wmem_epan_scope(), wmem_str_hash, g_str_equal);
+ register_x11_extensions();
+
+ x11_module = prefs_register_protocol(proto_x11, NULL);
+ prefs_register_bool_preference(x11_module, "desegment",
+ "Reassemble X11 messages spanning multiple TCP segments",
+ "Whether the X11 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.",
+ &x11_desegment);
+}
+
+void
+proto_reg_handoff_x11(void)
+{
+ dissector_add_uint_range_with_preference("tcp.port", DEFAULT_X11_PORT_RANGE, x11_handle);
+}
+
+/*
+ * Editor modelines
+ *
+ * Local Variables:
+ * c-basic-offset: 6
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * ex: set shiftwidth=6 tabstop=8 expandtab:
+ * :indentSize=6:tabSize=8:noTabs=true:
+ */
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-07 10:31:24 +0000