/epan/dissectors/packet-x11.c

Large files files are truncated, but you can click here to view the full file

/* packet-x11.c
 * Routines for X11 dissection
 * Copyright 2000, Christophe Tronche <ch.tronche@computer.org>
 * Copyright 2003, Michael Shuldman
 *
 * $Id$
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

/* 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 <assert.h>
#include <string.h>
#include <ctype.h>

#include <glib.h>

#include <epan/packet.h>
#include <epan/conversation.h>
#include <epan/expert.h>
#include <epan/show_exception.h>
#include <epan/prefs.h>
#include <epan/emem.h>


#include "packet-x11-keysymdef.h"
#include "packet-x11.h"

#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_BE           0
#define BYTE_ORDER_LE           1
#define BYTE_ORDER_UNKNOWN      -1

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 {
      struct _x11_conv_data *next;
      GHashTable *seqtable;            /* hashtable of sequencenumber <-> opcode. */
      GHashTable *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];
      GHashTable *eventcode_funcs;      /* hashtable of eventcode <-> dissect_event() */
      GHashTable *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     */
      int       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 x11_conv_data_t *x11_conv_data_list = NULL;

static GHashTable *extension_table; /* hashtable of extension name <-> dispatch function */
static GHashTable *event_table;     /* hashtable of extension name <-> event info list */
static GHashTable *error_table;     /* hashtable of extension name <-> error list */
static GHashTable *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 expert_field ei_x11_invalid_format = EI_INIT;

/* desegmentation of X11 messages */
static gboolean x11_desegment = TRUE;

#define TCP_PORT_X11                    6000
#define TCP_PORT_X11_2                  6001
#define TCP_PORT_X11_3                  6002

/*
 * 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 gravity_vals[] = {
      {  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

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" },
      { 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 BadColor                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" },
      { BadColor,              "BadColor" },
      { 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 }
};

/* we have not seen packet before. */
#define PACKET_IS_NEW(pinfo) \
      (!((pinfo)->fd->flags.visited))

/************************************************************************
 ***                                                                  ***
 ***           F I E L D   D E C O D I N G   M A C R O S              ***
 ***                                                                  ***
 ************************************************************************/

#define VALUE8(tvb, offset) (tvb_get_guint8(tvb, offset))
#define VALUE16(tvb, offset) (byte_order == ENC_BIG_ENDIAN ? tvb_get_ntohs(tvb, offset) : tvb_get_letohs(tvb, offset))
#define VALUE32(tvb, offset) (byte_order == ENC_BIG_ENDIAN ? tvb_get_ntohl(tvb, offset) : tvb_get_letohl(tvb, offset))
#define FLOAT(tvb, offset) (byte_order == ENC_BIG_ENDIAN ? tvb_get_ntohieee_float(tvb, offset) : tvb_get_letohieee_float(tvb, offset))
#define DOUBLE(tvb, offset) (byte_order == ENC_BIG_ENDIAN ? tvb_get_ntohieee_double(tvb, offset) : tvb_get_letohieee_double(tvb, offset))

#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 BITFIELD(TYPE, position, name) {        \
      int unused;                                                 \
      int save = *offsetp;                                              \
      proto_tree_add_item(bitmask_tree, hf_x11_##position##_##name, tvb, bitmask_offset, \
                          bitmask_size, byte_order);                    \
      if (bitmask_value & proto_registrar_get_nth(hf_x11_##position##_##name) -> bitmask) { \
            TYPE(name);                                                 \
            unused = save + 4 - *offsetp;                               \
            if (unused)                                                 \
                  proto_tree_add_item(t, hf_x11_unused, tvb, *offsetp, unused, ENC_NA); \
            *offsetp = save + 4;                                        \
      }                                                                 \
}

#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 BITGRAVITY(name) { gravity(tvb, offsetp, t, hf_x11_##name, "Forget"); }
#define BITMASK(name, size) {\
      proto_item *bitmask_ti; \
      guint32 bitmask_value; \
      int bitmask_offset; \
      int bitmask_size; \
      proto_tree *bitmask_tree; \
      bitmask_value = ((size == 1) ? (guint32)VALUE8(tvb, *offsetp) : \
                       ((size == 2) ? (guint32)VALUE16(tvb, *offsetp) : \
                                      (guint32)VALUE32(tvb, *offsetp))); \
      bitmask_offset = *offsetp; \
      bitmask_size = size; \
      bitmask_ti = proto_tree_add_uint(t, hf_x11_##name##_mask, tvb, *offsetp, size, bitmask_value); \
      bitmask_tree = proto_item_add_subtree(bitmask_ti, ett_x11_##name##_mask); \
      *offsetp += size;
#define ENDBITMASK      }
#define BITMASK8(name)  BITMASK(name, 1);
#define BITMASK16(name) BITMASK(name, 2);
#define BITMASK32(name) BITMASK(name, 4);
#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_item *event_ti;                                           \
      proto_tree *event_proto_tree;                                   \
      next_tvb = tvb_new_subset(tvb, offset, next_offset - offset,    \
                                next_offset - offset);                \
      eventcode = tvb_get_guint8(next_tvb, 0);                        \
      sent = (eventcode & 0x80) ? "Sent-" : "";                       \
      event_ti = proto_tree_add_text(t, next_tvb, 0, -1,              \
                              "event: %d (%s)",                       \
                               eventcode,                             \
                               val_to_str(eventcode & 0x7F,           \
                                          state->eventcode_vals,      \
                                          "<Unknown eventcode %u>")); \
      event_proto_tree = proto_item_add_subtree(event_ti,             \
                                                ett_x11_event);       \
      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, 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 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 = VALUE8(tvb, *offsetp);                             \
      proto_tree_add_uint_format(t, hf_x11_opcode, tvb, *offsetp, \
            1, opcode,  "opcode: %u (%s)", opcode,                \
            val_to_str_const(opcode, state->opcode_vals, "Unknown"));   \
      *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 UNUSED(x)      { proto_tree_add_item(t, hf_x11_unused, 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 WINGRAVITY(name) { gravity(tvb, offsetp, t, hf_x11_##name, "Unmap"); }

#define VISUALID(name) { gint32 v = VALUE32(tvb, *offsetp); \
    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 = VALUE16(tvb, *offsetp);                                         \
      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(tvb, offset, length_remaining, plen); \
                                                                      \
      if (sep == NULL) {                                              \
            col_set_str(pinfo->cinfo, COL_INFO, str);                 \
            sep = ":";                                                \
      }                                                               \
                                                                      \
      TRY {                                                           \
            func(next_tvb, pinfo, tree, …