epan/dissectors/packet-glusterfs_hndsk.c

   1 /* packet-gluster_hndsk.c
   2  * Routines for GlusterFS Handshake dissection
   3  * Copyright 2012, Niels de Vos <ndevos@redhat.com>
   4  *
   5  * Wireshark - Network traffic analyzer
   6  * By Gerald Combs <gerald@wireshark.org>
   7  * Copyright 1998 Gerald Combs
   8  *
   9  * SPDX-License-Identifier: GPL-2.0-or-later
  10  *
  11  *
  12  * References to source files point in general to the glusterfs sources.
  13  * There is currently no RFC or other document where the protocol is
  14  * completely described. The glusterfs sources can be found at:
  15  * - http://git.gluster.com/?p=glusterfs.git
  16  * - https://github.com/gluster/glusterfs
  17  *
  18  * The coding-style is roughly the same as the one use in the Linux kernel,
  19  * see http://www.kernel.org/doc/Documentation/CodingStyle.
  20  */
  21
  22 #include "config.h"
  23
  24 #include <epan/packet.h>
  25 #include <epan/tfs.h>
  26
  27 #include "packet-rpc.h"
  28 #include "packet-gluster.h"
  29
  30 void proto_register_gluster_hndsk(void);
  31 void proto_reg_handoff_gluster_hndsk(void);
  32 void proto_register_gluster_cbk(void);
  33 void proto_reg_handoff_gluster_cbk(void);
  34
  35 /* Initialize the protocol and registered fields */
  36 static int proto_gluster_cbk;
  37 static int proto_gluster_hndsk;
  38
  39 /* programs and procedures */
  40 static int hf_gluster_cbk_proc;
  41 static int hf_gluster_hndsk_proc;
  42 static int hf_gluster_hndsk_dict;
  43 static int hf_gluster_hndsk_spec;               /* GETSPEC Reply */
  44 static int hf_gluster_hndsk_key;                /* GETSPEC Call */
  45 static int hf_gluster_hndsk_event_op;   /* EVENT NOTIFY call */
  46 static int hf_gluster_hndsk_uid;                /* LOCK VERSION*/
  47 static int hf_gluster_hndsk_op_errstr;  /* GETVOLUMEINFO */
  48 static int hf_gluster_hndsk_lk_ver;
  49 static int hf_gluster_hndsk_flags;
  50
  51 /* Initialize the subtree pointers */
  52 static int ett_gluster_cbk;
  53 static int ett_gluster_cbk_flags;
  54 static int ett_gluster_hndsk;
  55
  56 /* upcall, used for cache-invalidation etc. */
  57 static int hf_gluster_cbk_gfid;
  58 static int hf_gluster_cbk_upcall_event_type;
  59 static int hf_gluster_cbk_ci_flags;
  60 static int hf_gluster_cbk_ci_expire_time_attr;
  61 static int hf_gluster_cbk_ci_stat;
  62 static int hf_gluster_cbk_ci_parent_stat;
  63 static int hf_gluster_cbk_ci_oldparent_stat;
  64 static int hf_gluster_cbk_xdata;
  65
  66 /* flags for upcall */
  67 static int hf_gluster_cbk_upcall_flag_nlink;
  68 static int hf_gluster_cbk_upcall_flag_mode;
  69 static int hf_gluster_cbk_upcall_flag_own;
  70 static int hf_gluster_cbk_upcall_flag_size;
  71 static int hf_gluster_cbk_upcall_flag_times;
  72 static int hf_gluster_cbk_upcall_flag_atime;
  73 static int hf_gluster_cbk_upcall_flag_perm;
  74 static int hf_gluster_cbk_upcall_flag_rename;
  75 static int hf_gluster_cbk_upcall_flag_forget;
  76 static int hf_gluster_cbk_upcall_flag_parent_times;
  77 static int hf_gluster_cbk_upcall_flag_xattr;
  78 static int hf_gluster_cbk_upcall_flag_xattr_rm;
  79
  80 /* procedures for GLUSTER_HNDSK_PROGRAM */
  81 static int
  82 gluster_hndsk_setvolume_reply(tvbuff_t *tvb, packet_info *pinfo,
  83                                                         proto_tree *tree, void* data)
  84 {
  85         int offset = 0;
  86         offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
  87         offset = gluster_rpc_dissect_dict(tree, tvb, hf_gluster_hndsk_dict,
  88                                                                 offset);
  89         return offset;
  90 }
  91
  92 static int
  93 gluster_hndsk_setvolume_call(tvbuff_t *tvb,
  94                                 packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
  95 {
  96         return gluster_rpc_dissect_dict(tree, tvb, hf_gluster_hndsk_dict, 0);
  97 }
  98
  99 static int
 100 gluster_hndsk_2_setvolume_reply(tvbuff_t *tvb, packet_info *pinfo,
 101                                                         proto_tree *tree, void* data)
 102 {
 103         int offset = 0;
 104         offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
 105         offset = gluster_rpc_dissect_dict(tree, tvb, hf_gluster_hndsk_dict,
 106                                                                 offset);
 107         return offset;
 108 }
 109
 110 static int
 111 gluster_hndsk_2_setvolume_call(tvbuff_t *tvb,
 112                                 packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
 113 {
 114         return gluster_rpc_dissect_dict(tree, tvb, hf_gluster_hndsk_dict, 0);
 115 }
 116
 117 static int
 118 gluster_hndsk_2_getspec_reply(tvbuff_t *tvb, packet_info *pinfo,
 119                                                         proto_tree *tree, void* data)
 120 {
 121         int offset = 0;
 122         offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
 123         offset = dissect_rpc_string(tvb, tree, hf_gluster_hndsk_spec, offset,
 124                                                                         NULL);
 125         offset = gluster_rpc_dissect_dict(tree, tvb, hf_gluster_hndsk_dict,
 126                                                                 offset);
 127         return offset;
 128 }
 129
 130 static int
 131 gluster_hndsk_2_getspec_call(tvbuff_t *tvb,
 132                                 packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
 133 {
 134         int offset = 0;
 135
 136         proto_tree_add_item(tree, hf_gluster_hndsk_flags, tvb, offset,
 137                                                                 4, ENC_BIG_ENDIAN);
 138         offset += 4;
 139         offset = dissect_rpc_string(tvb, tree, hf_gluster_hndsk_key, offset,
 140                                                                 NULL);
 141         offset = gluster_rpc_dissect_dict(tree, tvb, hf_gluster_hndsk_dict,
 142                                                                 offset);
 143         return offset;
 144 }
 145
 146 static int
 147 gluster_hndsk_2_set_lk_ver_reply(tvbuff_t *tvb, packet_info *pinfo,
 148                                                         proto_tree *tree, void* data)
 149 {
 150         int offset = 0;
 151         offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
 152         offset = dissect_rpc_uint32(tvb, tree,hf_gluster_hndsk_lk_ver, offset);
 153         return offset;
 154 }
 155
 156 static int
 157 gluster_hndsk_2_set_lk_ver_call(tvbuff_t *tvb,
 158                                 packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
 159 {
 160         int offset = 0;
 161
 162         offset = dissect_rpc_string(tvb, tree, hf_gluster_hndsk_uid, offset,
 163                                                                         NULL);
 164         offset = dissect_rpc_uint32(tvb, tree,hf_gluster_hndsk_lk_ver, offset);
 165         return offset;
 166 }
 167
 168 static int
 169 gluster_hndsk_2_event_notify_call(tvbuff_t *tvb,
 170                                 packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
 171 {
 172         int offset = 0;
 173
 174         offset = dissect_rpc_uint32(tvb, tree, hf_gluster_hndsk_event_op,
 175                                                                 offset);
 176         offset = gluster_rpc_dissect_dict(tree, tvb, hf_gluster_hndsk_dict,
 177                                                                 offset);
 178         return offset;
 179 }
 180
 181 /* In  rpc/xdr/src/glusterfs3-xdr.c. xdr_gf_event_notify_rsp */
 182
 183 static int
 184 gluster_hndsk_2_event_notify_reply(tvbuff_t *tvb,
 185                                         packet_info *pinfo, proto_tree *tree, void* data)
 186 {
 187         int offset = 0;
 188         offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
 189         offset = gluster_rpc_dissect_dict(tree, tvb, hf_gluster_hndsk_dict,
 190                                                                 offset);
 191         return offset;
 192 }
 193
 194 static int
 195 gluster_hndsk_2_get_volume_info_call(tvbuff_t *tvb, packet_info *pinfo _U_,
 196                                      proto_tree *tree, void* data _U_)
 197 {
 198         return gluster_rpc_dissect_dict(tree, tvb, hf_gluster_hndsk_dict, 0);
 199 }
 200
 201 static int
 202 gluster_hndsk_2_get_volume_info_reply(tvbuff_t *tvb, packet_info *pinfo,
 203                                       proto_tree *tree, void* data)
 204 {
 205         int offset = 0;
 206         offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
 207         offset = dissect_rpc_string(tvb, tree, hf_gluster_hndsk_op_errstr, offset,
 208                                     NULL);
 209         offset = gluster_rpc_dissect_dict(tree, tvb, hf_gluster_hndsk_dict,
 210                                           offset);
 211         return offset;
 212 }
 213
 214 static int
 215 glusterfs_rpc_dissect_upcall_flags(proto_tree *tree, tvbuff_t *tvb, int offset)
 216 {
 217         static int * const flag_bits[] = {
 218                 &hf_gluster_cbk_upcall_flag_nlink,
 219                 &hf_gluster_cbk_upcall_flag_mode,
 220                 &hf_gluster_cbk_upcall_flag_own,
 221                 &hf_gluster_cbk_upcall_flag_size,
 222                 &hf_gluster_cbk_upcall_flag_times,
 223                 &hf_gluster_cbk_upcall_flag_atime,
 224                 &hf_gluster_cbk_upcall_flag_perm,
 225                 &hf_gluster_cbk_upcall_flag_rename,
 226                 &hf_gluster_cbk_upcall_flag_forget,
 227                 &hf_gluster_cbk_upcall_flag_parent_times,
 228                 &hf_gluster_cbk_upcall_flag_xattr,
 229                 &hf_gluster_cbk_upcall_flag_xattr_rm,
 230                 NULL
 231         };
 232
 233         if (tree)
 234                 proto_tree_add_bitmask(tree, tvb, offset,
 235                         hf_gluster_cbk_ci_flags, ett_gluster_cbk_flags,
 236                         flag_bits, ENC_BIG_ENDIAN);
 237
 238         offset += 4;
 239         return offset;
 240 }
 241
 242 /* In  rpc/xdr/src/glusterfs3-xdr.c. xdr_gfs3_cbk_cache_invalidation_req */
 243 static int
 244 gluster_cbk_cache_invalidation_call(tvbuff_t *tvb,
 245                                 packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
 246 {
 247         int offset = 0;
 248
 249         offset = dissect_rpc_string(tvb, tree, hf_gluster_cbk_gfid, offset, NULL);
 250         offset = dissect_rpc_uint32(tvb, tree, hf_gluster_cbk_upcall_event_type, offset);
 251         offset = glusterfs_rpc_dissect_upcall_flags(tree, tvb, offset);
 252         offset = dissect_rpc_uint32(tvb, tree, hf_gluster_cbk_ci_expire_time_attr, offset);
 253         offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
 254                                         hf_gluster_cbk_ci_stat, offset);
 255         offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
 256                                         hf_gluster_cbk_ci_parent_stat, offset);
 257         offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
 258                                         hf_gluster_cbk_ci_oldparent_stat, offset);
 259         offset = gluster_rpc_dissect_dict(tree, tvb, hf_gluster_cbk_xdata, offset);
 260         return offset;
 261 }
 262
 263 static int
 264 gluster_hndsk_dissect_common_reply(tvbuff_t *tvb,
 265                                         packet_info *pinfo, proto_tree *tree, void* data)
 266 {
 267         return gluster_dissect_common_reply(tvb, 0, pinfo, tree, data);
 268 }
 269
 270 static const vsff gluster_hndsk_proc[] = {
 271         {
 272                 GF_HNDSK_NULL, "NULL",
 273                 dissect_rpc_void, dissect_rpc_void
 274         },
 275         {
 276                 GF_HNDSK_SETVOLUME, "SETVOLUME",
 277                 gluster_hndsk_setvolume_call, gluster_hndsk_setvolume_reply
 278         },
 279         { GF_HNDSK_GETSPEC, "GETSPEC", dissect_rpc_unknown, dissect_rpc_unknown },
 280         {
 281                 GF_HNDSK_PING, "PING",
 282                 dissect_rpc_void, gluster_hndsk_dissect_common_reply
 283         },
 284         { 0, NULL, NULL, NULL }
 285 };
 286
 287 static const vsff gluster_hndsk_2_proc[] = {
 288         {
 289                 GF_HNDSK_NULL, "NULL",
 290                 dissect_rpc_void, dissect_rpc_void
 291         },
 292         {
 293                 GF_HNDSK_SETVOLUME, "SETVOLUME",
 294                 gluster_hndsk_2_setvolume_call, gluster_hndsk_2_setvolume_reply
 295         },
 296         {
 297                 GF_HNDSK_GETSPEC, "GETSPEC",
 298                 gluster_hndsk_2_getspec_call, gluster_hndsk_2_getspec_reply
 299         },
 300         {
 301                 GF_HNDSK_PING, "PING",
 302                 dissect_rpc_void, glusterfs_gfs3_3_op_common_reply
 303         },
 304         {
 305                 GF_HNDSK_SET_LK_VER,"LOCK VERSION",
 306                 gluster_hndsk_2_set_lk_ver_call, gluster_hndsk_2_set_lk_ver_reply
 307         },
 308         {
 309                 GF_HNDSK_EVENT_NOTIFY, "EVENTNOTIFY",
 310                 gluster_hndsk_2_event_notify_call,
 311                 gluster_hndsk_2_event_notify_reply
 312         },
 313         {
 314                 GF_HNDSK_GET_VOLUME_INFO, "GETVOLUMEINFO",
 315                 gluster_hndsk_2_get_volume_info_call,
 316                 gluster_hndsk_2_get_volume_info_reply
 317         },
 318         { 0, NULL, NULL, NULL }
 319 };
 320
 321
 322 static const rpc_prog_vers_info gluster_hndsk_vers_info[] = {
 323         { 1, gluster_hndsk_proc, &hf_gluster_hndsk_proc },
 324         { 2, gluster_hndsk_2_proc, &hf_gluster_hndsk_proc },
 325 };
 326
 327
 328 static const value_string gluster_hndsk_proc_vals[] = {
 329         { GF_HNDSK_NULL,         "NULL" },
 330         { GF_HNDSK_SETVOLUME,    "DUMP" },
 331         { GF_HNDSK_GETSPEC,      "GETSPEC" },
 332         { GF_HNDSK_PING,         "PING" },
 333         { GF_HNDSK_SET_LK_VER,   "LOCK VERSION" },
 334         { GF_HNDSK_EVENT_NOTIFY, "EVENTNOTIFY" },
 335         { GF_HNDSK_GET_VOLUME_INFO, "GETVOLUMEINFO" },
 336         { 0, NULL }
 337 };
 338
 339 void
 340 proto_register_gluster_hndsk(void)
 341 {
 342         static hf_register_info hf[] = {
 343                 { &hf_gluster_hndsk_proc,
 344                         { "GlusterFS Handshake", "glusterfs.hndsk.proc",
 345                                 FT_UINT32, BASE_DEC,
 346                                 VALS(gluster_hndsk_proc_vals), 0, NULL, HFILL }
 347                 },
 348                 /* fields used by Gluster Handshake */
 349                 { &hf_gluster_hndsk_dict,
 350                         { "Dict", "glusterfs.hndsk.dict", FT_STRING, BASE_NONE,
 351                                 NULL, 0, NULL, HFILL }
 352                 },
 353                 /* For Gluster handshake event notify */
 354                 { &hf_gluster_hndsk_event_op,
 355                        { "Event Op", "glusterfs.hndsk.event_notify_op",
 356                                 FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }
 357                 },
 358                 { &hf_gluster_hndsk_key,
 359                         { "Key", "glusterfs.hndsk.getspec.key", FT_STRING,
 360                                 BASE_NONE, NULL, 0, NULL, HFILL }
 361                 },
 362                 { &hf_gluster_hndsk_spec,
 363                         /* FIXME: rename spec to something clearer */
 364                         { "Spec", "glusterfs.hndsk.getspec", FT_STRING,
 365                                 BASE_NONE, NULL, 0, NULL, HFILL }
 366                 },
 367                 /* For hand shake set_lk_ver */
 368                 { &hf_gluster_hndsk_uid,
 369                         { "Name", "glusterfs.hndsk.uid", FT_STRING, BASE_NONE,
 370                                 NULL, 0, NULL, HFILL }
 371                 },
 372                 { &hf_gluster_hndsk_lk_ver,
 373                         { "Event Op", "glusterfs.hndsk.lk_ver", FT_UINT32,
 374                                 BASE_DEC, NULL, 0, NULL, HFILL }
 375                 },
 376                 { &hf_gluster_hndsk_flags,
 377                         { "Flags", "glusterfs.hndsk.flags", FT_UINT32, BASE_OCT,
 378                                 NULL, 0, NULL, HFILL }
 379                 },
 380                 /* For handshake getvolumeinfo */
 381                 { &hf_gluster_hndsk_op_errstr,
 382                         { "Op Errstr", "glusterfs.hndsk.getvolumeinfo.op_errstr", FT_STRING,
 383                                 BASE_NONE, NULL, 0, NULL, HFILL }
 384                 }
 385         };
 386
 387         /* Setup protocol subtree array */
 388         static int *ett[] = {
 389                 &ett_gluster_hndsk
 390         };
 391
 392         /* Register the protocol name and description */
 393         proto_gluster_hndsk = proto_register_protocol("GlusterFS Handshake",
 394                                                 "GlusterFS Handshake",
 395                                                 "glusterfs.hndsk");
 396         proto_register_subtree_array(ett, array_length(ett));
 397         proto_register_field_array(proto_gluster_hndsk, hf, array_length(hf));
 398
 399 }
 400
 401 void
 402 proto_reg_handoff_gluster_hndsk(void)
 403 {
 404         rpc_init_prog(proto_gluster_hndsk, GLUSTER_HNDSK_PROGRAM,
 405             ett_gluster_hndsk,
 406             G_N_ELEMENTS(gluster_hndsk_vers_info), gluster_hndsk_vers_info);
 407 }
 408
 409 /* Legacy GlusterFS Callback procedures, they don't contain any data. */
 410 static const vsff gluster_cbk_proc[] = {
 411         { GF_CBK_NULL,      "NULL",      dissect_rpc_void, dissect_rpc_void },
 412         { GF_CBK_FETCHSPEC, "FETCHSPEC", dissect_rpc_unknown, dissect_rpc_unknown },
 413         { GF_CBK_INO_FLUSH, "INO_FLUSH", dissect_rpc_unknown, dissect_rpc_unknown },
 414         { GF_CBK_EVENT_NOTIFY, "EVENTNOTIFY", dissect_rpc_unknown, dissect_rpc_unknown },
 415         { GF_CBK_GET_SNAPS, "GETSNAPS", dissect_rpc_unknown, dissect_rpc_unknown },
 416         { GF_CBK_CACHE_INVALIDATION, "CACHE_INVALIDATION",
 417           gluster_cbk_cache_invalidation_call, dissect_rpc_unknown },
 418         { 0, NULL, NULL, NULL }
 419 };
 420 static const rpc_prog_vers_info gluster_cbk_vers_info[] = {
 421         { 1, gluster_cbk_proc, &hf_gluster_cbk_proc },
 422 };
 423 static const value_string gluster_cbk_proc_vals[] = {
 424         { GF_CBK_NULL,      "NULL" },
 425         { GF_CBK_FETCHSPEC, "FETCHSPEC" },
 426         { GF_CBK_INO_FLUSH, "INO_FLUSH" },
 427         { GF_CBK_EVENT_NOTIFY, "EVENTNOTIFY" },
 428         { GF_CBK_GET_SNAPS, "GETSNAPS" },
 429         { GF_CBK_CACHE_INVALIDATION, "CACHE_INVALIDATION" },
 430         { 0, NULL }
 431 };
 432
 433 static const value_string gluster_cbk_upcall_event_type[] = {
 434         { GF_UPCALL_EVENT_NULL,      "NULL" },
 435         { GF_UPCALL_CACHE_INVALIDATION, "CACHE_INVALIDATION" },
 436         { 0, NULL }
 437 };
 438 static value_string_ext gluster_cbk_upcall_event_type_ext = VALUE_STRING_EXT_INIT(gluster_cbk_upcall_event_type);
 439
 440 void
 441 proto_register_gluster_cbk(void)
 442 {
 443         /* Setup list of header fields  See Section 1.6.1 for details */
 444         static hf_register_info hf[] = {
 445                 /* programs */
 446                 { &hf_gluster_cbk_proc,
 447                         { "GlusterFS Callback", "glusterfs.cbk.proc",
 448                                 FT_UINT32, BASE_DEC,
 449                                 VALS(gluster_cbk_proc_vals), 0, NULL, HFILL }
 450                 },
 451                 { &hf_gluster_cbk_gfid,
 452                         { "GFID", "glusterfs.cbk.gfid", FT_STRING, BASE_NONE,
 453                                 NULL, 0, NULL, HFILL }
 454                 },
 455                 { &hf_gluster_cbk_upcall_event_type,
 456                         { "Event Type", "glusterfs.cbk.upcall.event_type", FT_UINT32, BASE_DEC | BASE_EXT_STRING,
 457                                 &gluster_cbk_upcall_event_type_ext, 0, NULL, HFILL }
 458                 },
 459                 { &hf_gluster_cbk_ci_flags,
 460                         { "Flags", "glusterfs.cbk.cache_invalidation.flags", FT_UINT32, BASE_DEC_HEX,
 461                                 NULL, 0, NULL, HFILL }
 462                 },
 463                 { &hf_gluster_cbk_ci_expire_time_attr,
 464                         { "Expire Time Attr", "glusterfs.cbk.cache_invalidation.expire_time_attr",
 465                                 FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }
 466                 },
 467                 { &hf_gluster_cbk_ci_stat,
 468                         { "Stat", "glusterfs.cbk.cache_invalidation.stat", FT_NONE, BASE_NONE, NULL,
 469                                 0, NULL, HFILL }
 470                 },
 471                 { &hf_gluster_cbk_ci_parent_stat,
 472                         { "Parent Stat", "glusterfs.cbk.cache_invalidation.parent.stat", FT_NONE, BASE_NONE, NULL,
 473                                 0, NULL, HFILL }
 474                 },
 475                 { &hf_gluster_cbk_ci_oldparent_stat,
 476                         { "Old Parent Stat", "glusterfs.cbk.cache_invalidation.oldparent.stat",
 477                                 FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }
 478                 },
 479                 { &hf_gluster_cbk_xdata,
 480                         { "Xdata", "glusterfs.cbk.xdata", FT_STRING, BASE_NONE,
 481                                 NULL, 0, NULL, HFILL }
 482                 },
 483
 484                 /* upcall flags from libglusterfs/src/upcall-utils.h */
 485                 { &hf_gluster_cbk_upcall_flag_nlink,
 486                         { "NLINK", "glusterfs.cbk.cache_invalidation.flag.nlink",
 487                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000001,
 488                                 NULL, HFILL }
 489                 },
 490                 { &hf_gluster_cbk_upcall_flag_mode,
 491                         { "MODE", "glusterfs.cbk.cache_invalidation.flag.mode",
 492                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000002,
 493                                 NULL, HFILL }
 494                 },
 495                 { &hf_gluster_cbk_upcall_flag_own,
 496                         { "OWN", "glusterfs.cbk.cache_invalidation.flag.own",
 497                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000004,
 498                                 NULL, HFILL }
 499                 },
 500                 { &hf_gluster_cbk_upcall_flag_size,
 501                         { "SIZE", "glusterfs.cbk.cache_invalidation.flag.size",
 502                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000008,
 503                                 NULL, HFILL }
 504                 },
 505                 { &hf_gluster_cbk_upcall_flag_times,
 506                         { "TIMES", "glusterfs.cbk.cache_invalidation.flag.times",
 507                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000010,
 508                                 NULL, HFILL }
 509                 },
 510                 { &hf_gluster_cbk_upcall_flag_atime,
 511                         { "ATIME", "glusterfs.cbk.cache_invalidation.flag.atime",
 512                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000020,
 513                                 NULL, HFILL }
 514                 },
 515                 { &hf_gluster_cbk_upcall_flag_perm,
 516                         { "PERM", "glusterfs.cbk.cache_invalidation.flag.perm",
 517                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000040,
 518                                 NULL, HFILL }
 519                 },
 520                 { &hf_gluster_cbk_upcall_flag_rename,
 521                         { "RENAME", "glusterfs.cbk.cache_invalidation.flag.rename",
 522                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000080,
 523                                 NULL, HFILL }
 524                 },
 525                 { &hf_gluster_cbk_upcall_flag_forget,
 526                         { "FORGET", "glusterfs.cbk.cache_invalidation.flag.forget",
 527                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000100,
 528                                 NULL, HFILL }
 529                 },
 530                 { &hf_gluster_cbk_upcall_flag_parent_times,
 531                         { "PARENT_TIMES", "glusterfs.cbk.cache_invalidation.flag.parent_times",
 532                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000200,
 533                                 NULL, HFILL }
 534                 },
 535                 { &hf_gluster_cbk_upcall_flag_xattr,
 536                         { "XATTR", "glusterfs.cbk.cache_invalidation.flag.xattr",
 537                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000400,
 538                                 NULL, HFILL }
 539                 },
 540                 { &hf_gluster_cbk_upcall_flag_xattr_rm,
 541                         { "XATTR_RM", "glusterfs.cbk.cache_invalidation.flag.xattr_rm",
 542                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000800,
 543                                 NULL, HFILL }
 544                 },
 545         };
 546
 547         /* Setup protocol subtree array */
 548         static int *ett[] = {
 549                 &ett_gluster_cbk,
 550                 &ett_gluster_cbk_flags
 551         };
 552
 553         /* Register the protocol name and description */
 554         proto_gluster_cbk = proto_register_protocol("GlusterFS Callback",
 555                                         "GlusterFS Callback", "glusterfs.cbk");
 556         proto_register_subtree_array(ett, array_length(ett));
 557         proto_register_field_array(proto_gluster_cbk, hf, array_length(hf));
 558 }
 559
 560 void
 561 proto_reg_handoff_gluster_cbk(void)
 562 {
 563         rpc_init_prog(proto_gluster_cbk, GLUSTER_CBK_PROGRAM, ett_gluster_cbk,
 564             G_N_ELEMENTS(gluster_cbk_vers_info), gluster_cbk_vers_info);
 565 }
 566
 567 /*
 568  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 569  *
 570  * Local variables:
 571  * c-basic-offset: 8
 572  * tab-width: 8
 573  * indent-tabs-mode: t
 574  * End:
 575  *
 576  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 577  * :indentSize=8:tabSize=8:noTabs=false:
 578  */