epan/dissectors/packet-rsvd.c

   1 /* packet-rsvd.c
   2  * Routines for RSVD dissection
   3  * Copyright 2015, Richard Sharpe <realrichardsharpe@gmail.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 /*
  13  * RSVD, documented in [MS-RSVD].pdf, by Microsoft, the Remote Shared Virtual
  14  * Disk protocol.
  15  */
  16
  17 #include "config.h"
  18
  19 #include <epan/conversation.h>
  20 #include <epan/packet.h>
  21 #if 0
  22 #include "packet-smb-common.h"
  23 #endif
  24 #include "packet-windows-common.h"
  25 #include "packet-scsi.h"
  26
  27 void proto_register_rsvd(void);
  28
  29 static int proto_rsvd;
  30 static int hf_svhdx_protocol_id;
  31 static int hf_svhdx_protocol_version;
  32 static int hf_svhdx_operation_code;
  33 static int hf_svhdx_status;
  34 static int hf_svhdx_request_id;
  35 static int hf_svhdx_tunnel_scsi_length;
  36 static int hf_svhdx_tunnel_scsi_reserved1;
  37 static int hf_svhdx_tunnel_scsi_cdb_length;
  38 static int hf_svhdx_tunnel_scsi_sense_info_ex_length;
  39 static int hf_svhdx_tunnel_scsi_data_in;
  40 static int hf_svhdx_tunnel_scsi_reserved2;
  41 static int hf_svhdx_tunnel_scsi_srb_flags;
  42 static int hf_svhdx_tunnel_scsi_data_transfer_length;
  43 static int hf_svhdx_tunnel_scsi_reserved3;
  44 static int hf_svhdx_tunnel_scsi_cdb;
  45 static int hf_svhdx_tunnel_scsi_cdb_padding;
  46 static int hf_svhdx_tunnel_scsi_data;
  47 static int hf_svhdx_tunnel_scsi_auto_generated_sense;
  48 static int hf_svhdx_tunnel_scsi_srb_status;
  49 static int hf_svhdx_tunnel_scsi_sense_data_ex;
  50 static int hf_svhdx_tunnel_scsi_status;
  51 static int hf_svhdx_tunnel_file_info_server_version;
  52 static int hf_svhdx_tunnel_file_info_sector_size;
  53 static int hf_svhdx_tunnel_file_info_physical_sector_size;
  54 static int hf_svhdx_tunnel_file_info_reserved;
  55 static int hf_svhdx_tunnel_file_info_virtual_size;
  56 static int hf_svhdx_tunnel_disk_info_reserved1;
  57 static int hf_svhdx_tunnel_disk_info_blocksize;
  58 static int hf_svhdx_tunnel_disk_info_linkage_id;
  59 static int hf_svhdx_tunnel_disk_info_disk_type;
  60 static int hf_svhdx_tunnel_disk_info_disk_format;
  61 static int hf_svhdx_tunnel_disk_info_is_mounted;
  62 static int hf_svhdx_tunnel_disk_info_is_4k_aligned;
  63 static int hf_svhdx_tunnel_disk_info_reserved;
  64 static int hf_svhdx_tunnel_disk_info_file_size;
  65 static int hf_svhdx_tunnel_disk_info_virtual_disk_id;
  66 static int hf_svhdx_tunnel_validate_disk_reserved;
  67 static int hf_svhdx_tunnel_validate_disk_is_valid_disk;
  68 static int hf_svhdx_tunnel_srb_status_status_key;
  69 static int hf_svhdx_tunnel_srb_status_reserved;
  70 static int hf_svhdx_tunnel_srb_status_sense_info_auto_generated;
  71 static int hf_svhdx_tunnel_srb_status_srb_status;
  72 static int hf_svhdx_tunnel_srb_status_scsi_status;
  73 static int hf_svhdx_tunnel_srb_status_sense_info_ex_length;
  74 static int hf_svhdx_tunnel_srb_status_sense_data_ex;
  75 static int hf_svhdx_tunnel_safe_virtual_size;
  76 static int hf_svhdx_tunnel_transaction_id;
  77 static int hf_svhdx_tunnel_meta_operation_type;
  78 static int hf_svhdx_tunnel_padding;
  79 static int hf_svhdx_tunnel_resize_new_size;
  80 static int hf_svhdx_tunnel_resize_expand_only_flag;
  81 static int hf_svhdx_tunnel_resize_allow_unsafe_virt_size_flag;
  82 static int hf_svhdx_tunnel_resize_shrink_to_minimum_safe_size_flag;
  83 static int hf_svhdx_tunnel_meta_operation_start_reserved;
  84 static int hf_svhdx_tunnel_snapshot_type;
  85 static int hf_svhdx_tunnel_snapshot_id;
  86 static int hf_svhdx_tunnel_create_snapshot_flags;
  87 static int hf_svhdx_tunnel_create_snapshot_flag_enable_change_tracking;
  88 static int hf_svhdx_tunnel_create_snapshot_stage1;
  89 static int hf_svhdx_tunnel_create_snapshot_stage2;
  90 static int hf_svhdx_tunnel_create_snapshot_stage3;
  91 static int hf_svhdx_tunnel_create_snapshot_stage4;
  92 static int hf_svhdx_tunnel_create_snapshot_stage5;
  93 static int hf_svhdx_tunnel_create_snapshot_stage6;
  94 static int hf_svhdx_tunnel_create_snapshot_parameters_payload_size;
  95 static int hf_svhdx_tunnel_convert_dst_vhdset_name_len;
  96 static int hf_svhdx_tunnel_convert_dst_vhdset_name;
  97 static int hf_svhdx_tunnel_delete_snapshot_persist_reference;
  98 static int hf_svhdx_tunnel_meta_op_query_progress_current_progress;
  99 static int hf_svhdx_tunnel_meta_op_query_progress_complete_value;
 100 static int hf_svhdx_tunnel_vhdset_information_type;
 101 static int hf_svhdx_tunnel_vhdset_snapshot_creation_time;
 102 static int hf_svhdx_tunnel_vhdset_is_valid_snapshot;
 103 static int hf_svhdx_tunnel_vhdset_parent_snapshot_id;
 104 static int hf_svhdx_tunnel_vhdset_log_file_id;
 105
 106 static int ett_rsvd;
 107 static int ett_svhdx_tunnel_op_header;
 108 static int ett_svhdx_tunnel_scsi_request;
 109 static int ett_rsvd_create_snapshot_flags;
 110
 111 static const value_string rsvd_operation_code_vals[] = {
 112         { 0x02001001, "RSVD_TUNNEL_GET_INITIAL_INFO" },
 113         { 0x02001002, "RSVD_TUNNEL_SCSI" },
 114         { 0x02001003, "RSVD_TUNNEL_CHECK_CONNECTION_STATUS" },
 115         { 0x02001004, "RSVD_TUNNEL_SRB_STATUS" },
 116         { 0x02001005, "RSVD_TUNNEL_GET_DISK_INFO" },
 117         { 0x02001006, "RSVD_TUNNEL_VALIDATE_DISK" },
 118         { 0x02002101, "RSVD_TUNNEL_META_OPERATION_START" },
 119         { 0x02002002, "RSVD_TUNNEL_META_OPERATION_QUERY_PROGRESS" },
 120         { 0x02002005, "RSVD_TUNNEL_VHDSET_QUERY_INFORMATION" },
 121         { 0x02002006, "RSVD_TUNNEL_DELETE_SNAPSHOT" },
 122         { 0x02002008, "RSVD_TUNNEL_CHANGE_TRACKING_GET_PARAMETERS" },
 123         { 0x02002009, "RSVD_TUNNEL_CHANGE_TRACKING_START" },
 124         { 0x0200200A, "RSVD_TUNNEL_CHANGE_TRACKING_STOP" },
 125         { 0x0200200C, "RSVD_TUNNEL_QUERY_VIRTUAL_DISK_CHANGES" },
 126         { 0x0200200D, "RSVD_TUNNEL_QUERY_SAFE_SIZE" },
 127         { 0, NULL }
 128 };
 129
 130 static const value_string rsvd_sense_info_vals[] = {
 131         { 0x0, "Sense Info Not Auto Generated" },
 132         { 0x1, "Sense Info Auto Generated" },
 133         { 0, NULL }
 134 };
 135
 136 static const value_string rsvd_disk_type_vals[] = {
 137         { 0x02, "VHD_TYPE_FIXED" },
 138         { 0x03, "VHD_TYPE_DYNAMIC" },
 139         { 0, NULL }
 140 };
 141
 142 static const value_string rsvd_disk_format_vals[] = {
 143         { 0x03, "VIRTUAL_STORAGE_TYPE_DEVICE_VHDX" },
 144         { 0x04, "VIRTUAL_STORAGE_TYPE_DEVICE_VHDSET" },
 145         { 0, NULL }
 146 };
 147
 148 /*
 149  * We need this data to handle SCSI requests and responses, I think
 150  */
 151 typedef struct _rsvd_task_data_t {
 152         uint32_t request_frame;
 153         uint32_t response_frame;
 154         itlq_nexus_t *itlq;
 155 } rsvd_task_data_t;
 156
 157 typedef struct _rsvd_conv_data_t {
 158         wmem_map_t *tasks;
 159         wmem_tree_t *itl;
 160         rsvd_task_data_t *task;
 161         conversation_t *conversation;
 162 } rsvd_conv_data_t;
 163
 164 static rsvd_conv_data_t *rsvd_conv_data;
 165
 166 static proto_tree *top_tree;
 167
 168 static itl_nexus_t *
 169 get_itl_nexus(packet_info *pinfo)
 170 {
 171     itl_nexus_t *itl = NULL;
 172
 173     if (!(itl = (itl_nexus_t *)wmem_tree_lookup32_le(rsvd_conv_data->itl, pinfo->num))) {
 174         itl = wmem_new(wmem_file_scope(), itl_nexus_t);
 175         itl->cmdset = 0xff;
 176         itl->conversation = rsvd_conv_data->conversation;
 177         wmem_tree_insert32(rsvd_conv_data->itl, pinfo->num, itl);
 178     }
 179
 180     return itl;
 181 }
 182
 183 static int
 184 dissect_RSVD_GET_INITIAL_INFO(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)
 185 {
 186     proto_tree *gfi_sub_tree;
 187     proto_item *gfi_sub_item;
 188
 189     if (!request) {
 190         gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_GET_INITIAL_INFO_RESPONSE");
 191
 192         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_file_info_server_version, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 193         offset += 4;
 194
 195         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_file_info_sector_size, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 196         offset += 4;
 197
 198         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_file_info_physical_sector_size, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 199         offset += 4;
 200
 201         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_file_info_reserved, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 202         offset += 4;
 203
 204         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_file_info_virtual_size, tvb, offset, 8, ENC_LITTLE_ENDIAN);
 205         offset += 8;
 206     }
 207
 208     return offset;
 209 }
 210
 211 static const value_string rsvd_data_in_vals[] = {
 212         { 0x00, "Client is requesting data from the server" },
 213         { 0x01, "Client is sending data to the server" },
 214         { 0x02, "Client is neither sending nor requesting an additional data buffer" },
 215         { 0, NULL }
 216 };
 217
 218 static void
 219 dissect_scsi_payload_databuffer(tvbuff_t *tvb, packet_info *pinfo, int offset, uint32_t data_transfer_length, bool request)
 220 {
 221     tvbuff_t *data_tvb = NULL;
 222     int tvb_len, tvb_rlen;
 223
 224     tvb_len = tvb_captured_length_remaining(tvb, offset);
 225     if (tvb_len > (int)data_transfer_length)
 226         tvb_len = data_transfer_length;
 227
 228     tvb_rlen = tvb_reported_length_remaining(tvb, offset);
 229     if (tvb_rlen > (int)data_transfer_length)
 230         tvb_rlen = data_transfer_length;
 231
 232     data_tvb = tvb_new_subset_length_caplen(tvb, offset, tvb_len, tvb_rlen);
 233
 234     if (rsvd_conv_data->task && rsvd_conv_data->task->itlq) {
 235         rsvd_conv_data->task->itlq->task_flags = SCSI_DATA_READ |
 236                                                  SCSI_DATA_WRITE;
 237         rsvd_conv_data->task->itlq->data_length = data_transfer_length;
 238         rsvd_conv_data->task->itlq->bidir_data_length = data_transfer_length;
 239         dissect_scsi_payload(data_tvb, pinfo, top_tree, request,
 240                              rsvd_conv_data->task->itlq,
 241                              get_itl_nexus(pinfo), 0);
 242     }
 243 }
 244
 245 /*
 246  * Dissect a tunnelled SCSI request and call the SCSI dissector where
 247  * needed.
 248  */
 249 static int
 250 dissect_RSVD_TUNNEL_SCSI(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset, int16_t len, bool request, uint64_t request_id)
 251 {
 252     proto_tree *sub_tree;
 253     proto_item *sub_item;
 254     uint32_t length;
 255     uint32_t cdb_length;
 256     uint8_t data_in;
 257     uint32_t data_transfer_length;
 258     uint32_t sense_info_ex_length;
 259     conversation_t *conversation;
 260
 261     conversation = find_or_create_conversation(pinfo);
 262     rsvd_conv_data = (rsvd_conv_data_t *)conversation_get_proto_data(conversation, proto_rsvd);
 263
 264     if (!rsvd_conv_data) {
 265         rsvd_conv_data = wmem_new(wmem_file_scope(), rsvd_conv_data_t);
 266         rsvd_conv_data->tasks = wmem_map_new(wmem_file_scope(),
 267                                              wmem_int64_hash,
 268                                              g_int64_equal);
 269         rsvd_conv_data->itl   = wmem_tree_new(wmem_file_scope());
 270         rsvd_conv_data->conversation = conversation;
 271         conversation_add_proto_data(conversation, proto_rsvd, rsvd_conv_data);
 272     }
 273
 274     rsvd_conv_data->task = NULL;
 275     rsvd_conv_data->task = (rsvd_task_data_t *)wmem_map_lookup(rsvd_conv_data->tasks, (const void *)&request_id);
 276     if (!pinfo->fd->visited) {
 277         if (rsvd_conv_data->task == NULL) {
 278             uint64_t *key_copy = wmem_new(wmem_file_scope(), uint64_t);
 279
 280             *key_copy = request_id;
 281             rsvd_conv_data->task = wmem_new0(wmem_file_scope(), rsvd_task_data_t);
 282             rsvd_conv_data->task->itlq = wmem_new0(wmem_file_scope(),
 283                                                   itlq_nexus_t);
 284             rsvd_conv_data->task->itlq->lun = 0xffff;
 285             rsvd_conv_data->task->itlq->scsi_opcode = 0xffff;
 286             rsvd_conv_data->task->itlq->fc_time = pinfo->abs_ts;
 287             wmem_map_insert(rsvd_conv_data->tasks, (const void *)key_copy,
 288                             rsvd_conv_data->task);
 289         }
 290         if (request) {
 291             rsvd_conv_data->task->request_frame = pinfo->num;
 292             rsvd_conv_data->task->itlq->first_exchange_frame = pinfo->num;
 293         } else {
 294             rsvd_conv_data->task->response_frame = pinfo->num;
 295             rsvd_conv_data->task->itlq->last_exchange_frame = pinfo->num;
 296         }
 297     }
 298
 299     sub_tree = proto_tree_add_subtree_format(parent_tree, tvb, offset, len, ett_svhdx_tunnel_scsi_request, &sub_item, "SVHDX_TUNNEL_SCSI_%s", (request ? "REQUEST" : "RESPONSE"));
 300
 301     if (request) {
 302         tvbuff_t *scsi_cdb = NULL;
 303
 304         /* Length */
 305         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_length, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 306         offset += 2;
 307
 308         /* Reserved1 */
 309         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_reserved1, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 310         offset += 2;
 311
 312         /* CDBLength */
 313         cdb_length = tvb_get_uint8(tvb, offset);
 314         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_cdb_length, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 315         offset++;
 316
 317         /* SensInfoExLength */
 318         /* You'll notice that there is no SenseDataEx field in the request.
 319          * This field is pointless and ignored. In some versions Microsoft
 320          * said that this field MUST be set to zero; recent versions say
 321          * that it SHOULD be set to 20 (which is the size of the CDBBuffer
 322          * plus Reserved3.) */
 323         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_sense_info_ex_length, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 324         offset++;
 325
 326         /* DataIn */
 327         data_in = tvb_get_uint8(tvb, offset);
 328         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_data_in, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 329         offset++;
 330
 331         /* Reserved2 */
 332         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_reserved2, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 333         offset++;
 334
 335         /* SrbFlags */
 336         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_srb_flags, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 337         offset += 4;
 338
 339         /* DataTransferLength */
 340         data_transfer_length = tvb_get_letohl(tvb, offset);
 341         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_data_transfer_length, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 342         offset += 4;
 343
 344         /* CDBBuffer */
 345         scsi_cdb = tvb_new_subset_length_caplen(tvb,
 346                                   offset,
 347                                   cdb_length,
 348                                   tvb_reported_length_remaining(tvb, offset));
 349         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_cdb, tvb, offset, cdb_length, ENC_NA);
 350         offset += cdb_length;
 351         if (cdb_length < 16) {
 352             /*
 353              * CDBBuffer is always 16 bytes - see MS-RSVD section 2.2.4.7
 354              * "SVHDX_TUNNEL_SCSI_REQUEST Structure":
 355              *
 356              *     https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rsvd/e8bcb003-97b3-41ef-9689-cd2d1668a9cc
 357              *
 358              * If CDB is actually smaller, we need to define padding bytes
 359              */
 360             uint32_t cdb_padding_length = 16 - cdb_length;
 361             proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_cdb_padding, tvb, offset, cdb_padding_length, ENC_NA);
 362             offset += cdb_padding_length;
 363         }
 364
 365         /* Reserved3 */
 366         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_reserved3, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 367         offset += 4;
 368
 369         /* DataBuffer */
 370         if (data_transfer_length) {
 371             proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_data, tvb, offset, data_transfer_length, ENC_NA);
 372         }
 373
 374         /*
 375          * Now the SCSI Request
 376          */
 377         if (rsvd_conv_data->task && rsvd_conv_data->task->itlq) {
 378             dissect_scsi_cdb(scsi_cdb, pinfo, top_tree, SCSI_DEV_SMC, rsvd_conv_data->task->itlq, get_itl_nexus(pinfo));
 379             if (data_in == 0) { /* Only OUT operations have meaningful SCSI payload in request packet */
 380                 dissect_scsi_payload_databuffer(tvb, pinfo, offset, data_transfer_length, request);
 381             }
 382         }
 383
 384         /* increment after DataBuffer */
 385         offset += data_transfer_length;
 386     } else {
 387         uint8_t scsi_status = 0;
 388
 389         /* Length */
 390         proto_tree_add_item_ret_uint(sub_tree, hf_svhdx_tunnel_scsi_length, tvb, offset, 2, ENC_LITTLE_ENDIAN, &length);
 391         offset += 2;
 392
 393         /* A */
 394         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_auto_generated_sense, tvb, offset, 1, ENC_BIG_ENDIAN);
 395
 396         /* SrbStatus */
 397         proto_tree_add_bits_item(sub_tree, hf_svhdx_tunnel_scsi_srb_status, tvb, offset * 8 + 1, 7, ENC_BIG_ENDIAN);
 398         offset++;
 399
 400         /* ScsiStatus */
 401         scsi_status = tvb_get_uint8(tvb, offset);
 402         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_status, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 403         offset++;
 404
 405         /* CdbLength */
 406         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_cdb_length, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 407         offset++;
 408
 409         /* SensInfoExLength */
 410         sense_info_ex_length = tvb_get_uint8(tvb, offset);
 411         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_sense_info_ex_length, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 412         offset++;
 413
 414         /* DataIn */
 415         data_in = tvb_get_uint8(tvb, offset);
 416         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_data_in, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 417         offset++;
 418
 419         /* Reserved */
 420         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_reserved2, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 421         offset++;
 422
 423         /* SrbFlags */
 424         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_srb_flags, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 425         offset += 4;
 426
 427         /* DataTransferLength */
 428         data_transfer_length = tvb_get_letohl(tvb, offset);
 429         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_data_transfer_length, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 430         offset += 4;
 431
 432         /* SenseDataEx */
 433         /* Microsoft kept going back and forth with this field. Up through
 434          * version 6.0 of the MS-RSVD specification, SenseInfoExLength had
 435          * the length of SenseDataEx, a variable length fields. In 7.0,
 436          * it was changed so that SenseDataEx was a fixed length 20 byte
 437          * field, and SenseInfoExLength had the number of bytes, of the
 438          * data actually contained in the field, which had to be 20 or fewer.
 439          * Then in 11.0 it was changed back.
 440          * In the 7.0-10.0 case, the 20 byte field seemed to actually
 441          * contain the CDB + padding + Reserved3 from the Request copied back.
 442          * Luckily there's also a Length field that measures the size of
 443          * the structure excluding the DataBuffer. In the versions with the
 444          * 20 byte fixed SenseDataEx field, the protocol notes that it MUST
 445          * MUST be set to the appropriate value of 36. (DataBuffer is the
 446          * only other possibly variable length field.)
 447          */
 448         if (length == 36 && sense_info_ex_length < 20) {
 449             sense_info_ex_length = 20;
 450         }
 451         proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_sense_data_ex, tvb, offset, sense_info_ex_length, ENC_NA);
 452         offset += sense_info_ex_length;
 453
 454         /* DataBuffer */
 455         if (data_transfer_length) {
 456             proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_data, tvb, offset, data_transfer_length, ENC_NA);
 457
 458             if (data_in == 1) { /* Only IN operations have meaningful SCSI payload in reply packet */
 459                 dissect_scsi_payload_databuffer(tvb, pinfo, offset, data_transfer_length, request);
 460             }
 461
 462             offset += data_transfer_length;
 463         }
 464
 465         /*
 466          * Now, the SCSI response
 467          */
 468         if (rsvd_conv_data->task && rsvd_conv_data->task->itlq) {
 469             dissect_scsi_rsp(tvb, pinfo, top_tree, rsvd_conv_data->task->itlq, get_itl_nexus(pinfo), scsi_status);
 470         }
 471     }
 472
 473     return offset;
 474 }
 475
 476 static int
 477 dissect_RSVD_SRB_STATUS(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)
 478 {
 479     proto_tree *gfi_sub_tree;
 480     proto_item *gfi_sub_item;
 481
 482     if (request) {
 483         gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_SRB_STATUS_REQUEST");
 484
 485         /* StatusKey */
 486         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_status_key, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 487         offset += 1;
 488
 489         /* Reserved */
 490         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_reserved, tvb, offset, 1, ENC_NA);
 491         offset += 27;
 492     } else {
 493         uint8_t sense_info_length;
 494
 495         gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_SRB_STATUS_RESPONSE");
 496
 497         /* StatusKey */
 498         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_status_key, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 499         offset += 1;
 500
 501         /* SenseInfoAutoGenerated and SrbStatus */
 502         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_sense_info_auto_generated, tvb, offset, 1, ENC_BIG_ENDIAN);
 503         proto_tree_add_bits_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_srb_status, tvb, offset * 8 + 1, 7, ENC_BIG_ENDIAN);
 504         offset += 1;
 505
 506         /* ScsiStatus */
 507         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_scsi_status, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 508         offset += 1;
 509
 510         /* SenseInfoExLength */
 511         sense_info_length = tvb_get_uint8(tvb, offset);
 512         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_sense_info_ex_length, tvb, offset, 1, ENC_NA);
 513         offset += 1;
 514
 515         /* SenseDataEx */
 516         /* For the same reasons as discussed in RSVD_TUNNEL_SCSI, in some
 517          * versions this field is a fixed 20 octets, and the length just
 518          * indicates the number of bytes of real sense data in it.
 519          * At least it's at the end; we'll just ignore the padding.
 520          */
 521         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_sense_data_ex, tvb, offset, sense_info_length, ENC_NA);
 522         offset += sense_info_length;
 523     }
 524
 525     return offset;
 526 }
 527
 528 static int
 529 dissect_RSVD_GET_DISK_INFO(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)
 530 {
 531     proto_tree *gfi_sub_tree;
 532     proto_item *gfi_sub_item;
 533
 534     if (request) {
 535         gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_GET_DISK_INFO_REQUEST");
 536
 537         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_reserved1, tvb, offset, 8, ENC_LITTLE_ENDIAN);
 538         offset += 8;
 539
 540         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_blocksize, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 541         offset += 4;
 542
 543         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_linkage_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 544         offset += 16;
 545
 546         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_is_mounted, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 547         offset += 1;
 548
 549         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_is_4k_aligned, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 550         offset += 1;
 551
 552         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_reserved, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 553         offset += 2;
 554
 555         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_file_size, tvb, offset, 8, ENC_LITTLE_ENDIAN);
 556         offset += 8;
 557
 558         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_virtual_disk_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 559         offset += 16;
 560     } else {
 561         gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_GET_DISK_INFO_RESPONSE");
 562
 563         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_disk_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 564         offset += 4;
 565
 566         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_disk_format, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 567         offset += 4;
 568
 569         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_blocksize, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 570         offset += 4;
 571
 572         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_linkage_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 573         offset += 16;
 574
 575         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_is_mounted, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 576         offset += 1;
 577
 578         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_is_4k_aligned, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 579         offset += 1;
 580
 581         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_reserved, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 582         offset += 2;
 583
 584         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_file_size, tvb, offset, 8, ENC_LITTLE_ENDIAN);
 585         offset += 8;
 586
 587         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_virtual_disk_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 588         offset += 16;
 589     }
 590
 591     return offset;
 592 }
 593
 594 static int
 595 dissect_RSVD_VALIDATE_DISK(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)
 596 {
 597     proto_tree *gfi_sub_tree;
 598     proto_item *gfi_sub_item;
 599
 600     if (request) {
 601         gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_VALIDATE_DISK_REQUEST");
 602
 603         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_validate_disk_reserved, tvb, offset, 56, ENC_NA);
 604         offset += 56;
 605     } else {
 606         gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_VALIDATE_DISK_RESPONSE");
 607
 608         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_validate_disk_is_valid_disk, tvb, offset, 1, ENC_NA);
 609         offset += 1;
 610     }
 611
 612     return offset;
 613 }
 614
 615 static const value_string rsvd_meta_operation_type_vals[] = {
 616         { 0x00, "SvhdxMetaOperationTypeResize" },
 617         { 0x01, "SvhdxMetaOperationTypeCreateSnapshot" },
 618         { 0x02, "SvhdxMetaOperationTypeOptimize" },
 619         { 0x03, "SvhdxMetaOperationTypeExtractVHD" },
 620         { 0x04, "SvhdxMetaOperationTypeConvertToVHDSet" },
 621         { 0x05, "SvhdxMetaOperationTypeApplySnapshot" },
 622         { 0, NULL }
 623 };
 624
 625 static const value_string svhdx_snapshot_type_vals[] = {
 626         { 0x01, "SvhdxSnapshotTypeVM" },
 627         { 0x03, "SvhdxSnapshotTypeCDP" },
 628         { 0x04, "SvhdxSnapshotTypeWriteable" },
 629         { 0, NULL }
 630 };
 631
 632 static const value_string svhdx_snapshot_stage_vals[] = {
 633         { 0x00, "SvhdxSnapshotStageInvalid" },
 634         { 0x01, "SvhdxSnapshotStageInitialize" },
 635         { 0x02, "SvhdxSnapshotStageBlockIO" },
 636         { 0x03, "SvhdxSnapshotStageSwitchObjectStore" },
 637         { 0x04, "SvhdxSnapshotStageUnblockIO" },
 638         { 0x05, "SvhdxSnapshotStageFinalize" },
 639         { 0, NULL }
 640 };
 641
 642 #define SVHDX_SNAPSHOT_DISK_FLAG_ENABLE_CHANGE_TRACKING 0x00000001
 643
 644 static int
 645 dissect_RSVD2_META_OPERATION_START(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)
 646 {
 647     static int * const meta_operation_create_snapshot_flags[] = {
 648         &hf_svhdx_tunnel_create_snapshot_flag_enable_change_tracking,
 649         NULL
 650     };
 651
 652     uint32_t operation_type = 0;
 653     uint32_t length = 0;
 654     proto_tree *gfi_sub_tree;
 655     proto_item *gfi_sub_item;
 656
 657     if (request) {
 658
 659         gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_META_OPERATION_START_REQUEST");
 660
 661         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_transaction_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 662         offset += 16;
 663
 664         operation_type = tvb_get_letohl(tvb, offset);
 665         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_meta_operation_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 666         offset += 4;
 667
 668         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_padding, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 669         offset += 4;
 670
 671         switch (operation_type) {
 672         case 0x00: /* SvhdxMetaOperationTypeResize */
 673             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_resize_new_size, tvb, offset, 8, ENC_LITTLE_ENDIAN);
 674             offset += 8;
 675
 676             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_resize_expand_only_flag, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 677             offset += 1;
 678
 679             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_resize_allow_unsafe_virt_size_flag, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 680             offset += 1;
 681
 682             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_resize_shrink_to_minimum_safe_size_flag, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 683             offset += 1;
 684
 685             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_meta_operation_start_reserved, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 686             offset += 1;
 687             break;
 688         case 0x01: /* SvhdxMetaOperationTypeCreateSnapshot */
 689             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 690             offset += 4;
 691
 692             proto_tree_add_bitmask(gfi_sub_tree, tvb, offset, hf_svhdx_tunnel_create_snapshot_flags,
 693                                    ett_rsvd_create_snapshot_flags, meta_operation_create_snapshot_flags, ENC_LITTLE_ENDIAN);
 694             offset += 4;
 695
 696             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_stage1, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 697             offset += 4;
 698
 699             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_stage2, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 700             offset += 4;
 701
 702             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_stage3, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 703             offset += 4;
 704
 705             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_stage4, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 706             offset += 4;
 707
 708             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_stage5, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 709             offset += 4;
 710
 711             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_stage6, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 712             offset += 4;
 713
 714             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 715             offset += 16;
 716
 717             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_parameters_payload_size, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 718             offset += 4;
 719
 720             break;
 721         case 0x02: /* SvhdxMetaOperationTypeOptimize */
 722             /* No Data, field MUST be empty */
 723             break;
 724         case 0x03: /* SvhdxMetaOperationTypeExtractVHD */
 725             /* TODO */
 726             break;
 727         case 0x04: /* SvhdxMetaOperationTypeConvertToVHDSet */
 728             length = tvb_get_letohl(tvb, offset);
 729             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_convert_dst_vhdset_name_len, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 730             offset += 4;
 731
 732             if (length) {
 733                 proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_convert_dst_vhdset_name, tvb, offset, length, ENC_UTF_16|ENC_LITTLE_ENDIAN);
 734             }
 735             break;
 736
 737         case 0x05: /* SvhdxMetaOperationTypeApplySnapshot */
 738             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 739             offset += 4;
 740
 741             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 742             offset += 16;
 743
 744             break;
 745         }
 746     }
 747     return offset;
 748 }
 749
 750 static int
 751 dissect_RSVD2_META_OPERATION_QUERY_PROGRESS(tvbuff_t *tvb,
 752             proto_tree *parent_tree, int offset, int16_t len, bool request, uint32_t status)
 753 {
 754     proto_tree *gfi_sub_tree;
 755     proto_item *gfi_sub_item;
 756
 757     if (request) {
 758         gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_META_OPERATION_QUERY_PROGRESS_REQUEST");
 759
 760         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_transaction_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 761         offset += 16;
 762     } else {
 763         if (status == 0) { /* If status is not successful, RSVD response buffer is filled by data from request buffer and we should not parse output structure */
 764             gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_META_OPERATION_QUERY_PROGRESS_RESPONSE");
 765
 766             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_meta_op_query_progress_current_progress, tvb, offset, 8, ENC_LITTLE_ENDIAN);
 767             offset += 8;
 768
 769             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_meta_op_query_progress_complete_value, tvb, offset, 8, ENC_LITTLE_ENDIAN);
 770             offset += 8;
 771         }
 772     }
 773     return offset;
 774 }
 775
 776 static const value_string svhdx_vhdset_information_type_vals[] = {
 777         { 0x02, "SvhdxVHDSetInformationTypeSnapshotList" },
 778         { 0x05, "SvhdxVHDSetInformationTypeSnapshotEntry" },
 779         { 0x08, "SvhdxVHDSetInformationTypeOptimizeNeeded" },
 780         { 0x09, "SvhdxVHDSetInformationTypeCdpSnapshotRoot" },
 781         { 0x0A, "SvhdxVHDSetInformationTypeCdpSnapshotActiveList" },
 782         { 0x0C, "SvhdxVHDSetInformationTypeCdpSnapshotInactiveList" },
 783         { 0, NULL }
 784 };
 785 static int
 786 dissect_RSVD2_VHDSET_QUERY_INFORMATION(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)
 787 {
 788     proto_tree *gfi_sub_tree;
 789     proto_item *gfi_sub_item;
 790
 791     if (request) {
 792         gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_VHDSET_QUERY_INFORMATION_REQUEST");
 793
 794         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_vhdset_information_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 795         offset += 4;
 796
 797         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 798         offset += 4;
 799
 800         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 801         offset += 16;
 802     } else {
 803         uint32_t vhdset_info_type = tvb_get_letohl(tvb, offset);
 804         switch (vhdset_info_type) {
 805         case 0x02: /* SvhdxVHDSetInformationTypeSnapshotList */
 806             gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_VHDSET_QUERY_INFORMATION_SNAPSHOT_LIST_RESPONSE");
 807
 808             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_vhdset_information_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 809             offset += 4;
 810             /* TODO: make full dissection */
 811
 812             break;
 813         case 0x05: /* SvhdxVHDSetInformationTypeSnapshotEntry */
 814             gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_VHDSET_QUERY_INFORMATION_SNAPSHOT_ENTRY_RESPONSE");
 815
 816             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_vhdset_information_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 817             offset += 4;
 818
 819             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_padding, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 820             offset += 4;
 821
 822             dissect_nttime(tvb, gfi_sub_tree, offset, hf_svhdx_tunnel_vhdset_snapshot_creation_time, ENC_LITTLE_ENDIAN);
 823             offset += 8;
 824
 825             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 826             offset += 4;
 827
 828             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_vhdset_is_valid_snapshot, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 829             offset += 4;
 830
 831             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 832             offset += 16;
 833
 834             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_vhdset_parent_snapshot_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 835             offset += 16;
 836
 837             proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_vhdset_log_file_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 838             offset += 16;
 839
 840             break;
 841         }
 842     }
 843     return offset;
 844 }
 845
 846 static int
 847 dissect_RSVD2_DELETE_SNAPSHOT(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)
 848 {
 849     proto_tree *gfi_sub_tree;
 850     proto_item *gfi_sub_item;
 851
 852     if (request) {
 853         gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_DELETE_SNAPSHOT_REQUEST");
 854
 855         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);
 856         offset += 16;
 857
 858         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_delete_snapshot_persist_reference, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 859         offset += 4;
 860
 861         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 862         offset += 4;
 863     }
 864     return offset;
 865 }
 866
 867 static int
 868 dissect_RSVD2_QUERY_SAFE_SIZE(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)
 869 {
 870     proto_tree *gfi_sub_tree;
 871     proto_item *gfi_sub_item;
 872
 873     if (!request) {
 874         gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_QUERY_SAFE_SIZE_RESPONSE");
 875
 876         proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_safe_virtual_size, tvb, offset, 8, ENC_LITTLE_ENDIAN);
 877         offset += 8;
 878     }
 879     return offset;
 880 }
 881
 882 static int
 883 dissect_rsvd(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void *data)
 884 {
 885     uint32_t header_bytes = 0;
 886     unsigned proto_id = 0;
 887     unsigned proto_version = 0;
 888     uint32_t operation_code = 0;
 889     uint32_t status;
 890     proto_item *ti;
 891     proto_tree *rsvd_tree;
 892     proto_item *sub_item;
 893     proto_tree *sub_tree;
 894     unsigned    offset = 0;
 895     uint16_t len;
 896     uint64_t request_id = 0;
 897     bool request = *(bool *)data;
 898
 899     top_tree = parent_tree;
 900
 901     len = tvb_reported_length(tvb);
 902
 903     col_set_str(pinfo->cinfo, COL_PROTOCOL, "RSVD");
 904
 905     col_clear(pinfo->cinfo, COL_INFO);
 906
 907     /*
 908      * The header bytes need to be pulled in as a 32bit LE value. And the
 909      * header is the same in a request or a response ...
 910      */
 911     header_bytes = tvb_get_letohl(tvb, 0); /* Get the header bytes */
 912     proto_id = header_bytes >> 24;
 913     proto_version = (header_bytes >> 12) & 0x0FFF;
 914     operation_code = header_bytes;
 915
 916     ti = proto_tree_add_item(parent_tree, proto_rsvd, tvb, offset, -1, ENC_NA);
 917
 918     rsvd_tree = proto_item_add_subtree(ti, ett_rsvd);
 919
 920     sub_tree = proto_tree_add_subtree(rsvd_tree, tvb, offset, (len>16) ? 16 : len, ett_svhdx_tunnel_op_header, &sub_item, "SVHDX_TUNNEL_OPERATION_HEADER");
 921
 922     /* ProtocolID */
 923     proto_tree_add_uint(sub_tree, hf_svhdx_protocol_id, tvb, offset, 4, proto_id);
 924
 925     /* ProtocolVersion */
 926     proto_tree_add_uint(sub_tree, hf_svhdx_protocol_version, tvb, offset, 4, proto_version);
 927
 928     /* Operation Code */
 929     proto_tree_add_uint(sub_tree, hf_svhdx_operation_code, tvb, offset, 4, operation_code);
 930     offset += 4;
 931
 932     /* Status */
 933     status = tvb_get_letohl(tvb, offset);
 934     proto_tree_add_item(sub_tree, hf_svhdx_status, tvb, offset, 4, ENC_LITTLE_ENDIAN);
 935     offset += 4;
 936
 937     /* RequestId */
 938     request_id = tvb_get_ntoh64(tvb, offset);
 939     proto_tree_add_item(sub_tree, hf_svhdx_request_id, tvb, offset, 8, ENC_LITTLE_ENDIAN);
 940     offset += 8;
 941
 942     col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s",
 943                     val_to_str(operation_code,
 944                                rsvd_operation_code_vals,
 945                                "Unknown Operation Code (0x%08X)"),
 946                     request ? "Request" : "Response");
 947
 948     proto_item_append_text(ti, ", %s %s",
 949                           val_to_str(operation_code,
 950                                      rsvd_operation_code_vals,
 951                                      "Unknown Operation Code (0x%08X)"),
 952                           request ? "Request" : "Response");
 953     /*
 954      * Now process the individual requests ...
 955      */
 956     switch (operation_code) {
 957     case 0x02001001:
 958         offset += dissect_RSVD_GET_INITIAL_INFO(tvb, rsvd_tree, offset, len - offset, request);
 959         break;
 960
 961     case 0x02001002:
 962         offset += dissect_RSVD_TUNNEL_SCSI(tvb, pinfo, rsvd_tree, offset, len - offset, request, request_id);
 963         break;
 964
 965     case 0x02001003:
 966
 967         /*
 968          * There is nothing more here.
 969          */
 970
 971         break;
 972
 973     case 0x02001004:
 974         offset += dissect_RSVD_SRB_STATUS(tvb, rsvd_tree, offset, len - offset, request);
 975         break;
 976
 977     case 0x02001005:
 978         offset += dissect_RSVD_GET_DISK_INFO(tvb, rsvd_tree, offset, len - offset, request);
 979         break;
 980
 981     case 0x02001006:
 982         offset += dissect_RSVD_VALIDATE_DISK(tvb, rsvd_tree, offset, len - offset, request);
 983         break;
 984     /* RSVD v2 operations */
 985     case 0x02002101:
 986         offset += dissect_RSVD2_META_OPERATION_START(tvb, rsvd_tree, offset, len - offset, request);
 987         break;
 988
 989     case 0x02002002:
 990         offset += dissect_RSVD2_META_OPERATION_QUERY_PROGRESS(tvb, rsvd_tree, offset, len - offset, request, status);
 991         break;
 992
 993     case 0x02002005:
 994         offset += dissect_RSVD2_VHDSET_QUERY_INFORMATION(tvb, rsvd_tree, offset, len - offset, request);
 995         break;
 996
 997     case 0x02002006:
 998         offset += dissect_RSVD2_DELETE_SNAPSHOT(tvb, rsvd_tree, offset, len - offset, request);
 999         break;
1000
1001     case 0x0200200D:
1002         offset += dissect_RSVD2_QUERY_SAFE_SIZE(tvb, rsvd_tree, offset, len - offset, request);
1003         break;
1004
1005     /* TODO: implement more dissectors for RSVD v2 */
1006
1007     default:
1008         break;
1009     }
1010
1011     return offset;
1012 }
1013
1014 void
1015 proto_register_rsvd(void)
1016 {
1017
1018     static hf_register_info hf[] = {
1019                 { &hf_svhdx_protocol_id,
1020                   { "ProtocolId", "rsvd.svhdx_protocol_id", FT_UINT8, BASE_DEC,
1021                     NULL, 0, NULL, HFILL }},
1022
1023                 { &hf_svhdx_protocol_version,
1024                   { "ProtocolVersion", "rsvd.svhdx_protocol_version", FT_UINT16, BASE_DEC,
1025                      NULL, 0, NULL, HFILL }},
1026
1027                 { &hf_svhdx_operation_code,
1028                   { "OperationCode", "rsvd.svhdx_operation_code", FT_UINT32, BASE_HEX,
1029                      VALS(rsvd_operation_code_vals), 0, "Operation Code", HFILL }},
1030
1031                 { &hf_svhdx_status,
1032                   { "Status", "rsvd.svhdx_status", FT_UINT32, BASE_HEX | BASE_EXT_STRING,
1033                     &NT_errors_ext, 0, NULL, HFILL }},
1034
1035
1036                 { &hf_svhdx_request_id,
1037                   { "RequestId", "rsvd.svhdx_request_id", FT_UINT64, BASE_HEX,
1038                     NULL, 0, NULL, HFILL }},
1039
1040                 { &hf_svhdx_tunnel_scsi_length,
1041                   { "Length", "rsvd.svhdx_length", FT_UINT16, BASE_DEC,
1042                     NULL, 0, NULL, HFILL }},
1043
1044                 { &hf_svhdx_tunnel_scsi_reserved1,
1045                   { "Reserved1", "rsvd.svhdx_scsi_reserved1", FT_UINT16, BASE_HEX,
1046                     NULL, 0, NULL, HFILL }},
1047
1048                 { &hf_svhdx_tunnel_scsi_cdb_length,
1049                   { "CDBLength", "rsvd.svhdx_scsi_cdb_length", FT_UINT8, BASE_DEC,
1050                     NULL, 0, NULL, HFILL }},
1051
1052                 { &hf_svhdx_tunnel_scsi_sense_info_ex_length,
1053                   { "SenseInfoExLength", "rsvd.svhdx_scsi_sense_info_ex_length", FT_UINT8, BASE_DEC,
1054                     NULL, 0, NULL, HFILL }},
1055
1056                 { &hf_svhdx_tunnel_scsi_data_in,
1057                   { "DataIn", "rsvd.svhdx_scsi_data_in", FT_UINT8, BASE_HEX,
1058                     VALS(rsvd_data_in_vals), 0, "SCSI CDB transfer type", HFILL }},
1059
1060                 { &hf_svhdx_tunnel_scsi_reserved2,
1061                   { "Reserved2", "rsvd.svhdx_scsi_reserved2", FT_UINT8, BASE_HEX,
1062                     NULL, 0, NULL, HFILL }},
1063
1064                 { &hf_svhdx_tunnel_scsi_srb_flags,
1065                   { "SRBFlags", "rsvd.svhdx_scsi_srbflags", FT_UINT32, BASE_HEX,
1066                     NULL, 0, NULL, HFILL }},
1067
1068                 { &hf_svhdx_tunnel_scsi_data_transfer_length,
1069                   { "DataTransferLength", "rsvd.svhdx_scsi_data_transfer_length", FT_UINT32, BASE_DEC,
1070                     NULL, 0, NULL, HFILL }},
1071
1072                 { &hf_svhdx_tunnel_scsi_reserved3,
1073                   { "Reserved3", "rsvd.svhdx_scsi_reserved3", FT_UINT32, BASE_HEX,
1074                     NULL, 0, NULL, HFILL }},
1075
1076                 { &hf_svhdx_tunnel_scsi_cdb,
1077                   { "CDB", "rsvd.svhdx_scsi_cdb", FT_BYTES, BASE_NONE,
1078                     NULL, 0, NULL, HFILL }},
1079
1080                 { &hf_svhdx_tunnel_scsi_cdb_padding,
1081                   { "CDBPadding", "rsvd.svhdx_scsi_cdb_padding", FT_BYTES, BASE_NONE,
1082                     NULL, 0, NULL, HFILL }},
1083
1084                 { &hf_svhdx_tunnel_scsi_data,
1085                   {"Data", "rsvd.svhdx_scsi_data", FT_BYTES, BASE_NONE,
1086                     NULL, 0, NULL, HFILL }},
1087
1088                 { &hf_svhdx_tunnel_scsi_auto_generated_sense,
1089                   {"AutoGeneratedSenseInfo", "rsvd.svhdx_auto_generated_sense_info", FT_UINT8, BASE_HEX,
1090                     VALS(rsvd_sense_info_vals), 0x80, NULL, HFILL }},
1091
1092                 { &hf_svhdx_tunnel_scsi_srb_status,
1093                   { "SrbStatus", "rsvd.svhdx_srb_status", FT_UINT8, BASE_HEX,
1094                     NULL, 0, NULL, HFILL }},
1095
1096                 { &hf_svhdx_tunnel_scsi_status,
1097                   { "ScsiStatus", "rsvd.svhdx_scsi_status", FT_UINT8, BASE_HEX,
1098                     NULL, 0, NULL, HFILL }},
1099
1100                 { &hf_svhdx_tunnel_scsi_sense_data_ex,
1101                   { "SenseDataEx", "rsvd.svhdx_scsi_sense_data_ex", FT_BYTES, BASE_NONE,
1102                     NULL, 0, NULL, HFILL }},
1103
1104                 { &hf_svhdx_tunnel_file_info_server_version,
1105                   { "ServerVersion", "rsvd.svhdx_file_info_server_version", FT_UINT32, BASE_DEC,
1106                     NULL, 0, NULL, HFILL }},
1107
1108                 { &hf_svhdx_tunnel_file_info_sector_size,
1109                   { "SectorSize", "rsvd.svhdx_file_info_sector_size", FT_UINT32, BASE_DEC,
1110                     NULL, 0, NULL, HFILL }},
1111
1112                 { &hf_svhdx_tunnel_file_info_physical_sector_size,
1113                   { "PhysicalSectorSize", "rsvd.svhdx_file_info_physical_sector_size", FT_UINT32, BASE_DEC,
1114                     NULL, 0, NULL, HFILL }},
1115
1116                 { &hf_svhdx_tunnel_file_info_reserved,
1117                   { "Reserved", "rsvd.svhdx_file_info_reserved", FT_UINT32, BASE_DEC,
1118                     NULL, 0, NULL, HFILL }},
1119
1120                 { &hf_svhdx_tunnel_file_info_virtual_size,
1121                   { "VirtualSize", "rsvd.svhdx_file_info_virtual_size", FT_UINT64, BASE_DEC,
1122                     NULL, 0, NULL, HFILL }},
1123
1124
1125                 { &hf_svhdx_tunnel_disk_info_reserved1,
1126                   { "Reserved1", "rsvd.svhdx_disk_info_reserved1", FT_UINT64, BASE_DEC,
1127                     NULL, 0, NULL, HFILL }},
1128
1129                 { &hf_svhdx_tunnel_disk_info_blocksize,
1130                   { "BlockSize", "rsvd.svhdx_disk_info_blocksize", FT_UINT32, BASE_DEC,
1131                     NULL, 0, NULL, HFILL }},
1132
1133                 { &hf_svhdx_tunnel_disk_info_linkage_id,
1134                   { "LinkageID", "rsvd.svhdx_disk_info_linkage_id", FT_GUID, BASE_NONE,
1135                     NULL, 0, NULL, HFILL }},
1136
1137                 { &hf_svhdx_tunnel_disk_info_disk_type,
1138                   { "DiskType", "rsvd.svhdx_disk_info_disk_type", FT_UINT32, BASE_HEX,
1139                      VALS(rsvd_disk_type_vals), 0, "Disk Type", HFILL }},
1140
1141                 { &hf_svhdx_tunnel_disk_info_disk_format,
1142                   { "DiskFormat", "rsvd.svhdx_disk_info_disk_format", FT_UINT32, BASE_HEX,
1143                      VALS(rsvd_disk_format_vals), 0, "Disk Format", HFILL }},
1144
1145                 { &hf_svhdx_tunnel_disk_info_is_mounted,
1146                   { "IsMounted", "rsvd.svhdx_tunnel_disk_info_is_mounted", FT_UINT8, BASE_DEC,
1147                     NULL, 0, NULL, HFILL }},
1148
1149                 { &hf_svhdx_tunnel_disk_info_is_4k_aligned,
1150                   { "Is4KAligned", "rsvd.svhdx_tunnel_disk_info_is_4k_aligned", FT_UINT8, BASE_DEC,
1151                     NULL, 0, NULL, HFILL }},
1152
1153                 { &hf_svhdx_tunnel_disk_info_reserved,
1154                   { "Reserved", "rsvd.svhdx_disk_info_reserved", FT_UINT16, BASE_DEC,
1155                     NULL, 0, NULL, HFILL }},
1156
1157                 { &hf_svhdx_tunnel_disk_info_file_size,
1158                   { "FileSize", "rsvd.svhdx_disk_info_file_size", FT_UINT64, BASE_DEC,
1159                     NULL, 0, NULL, HFILL }},
1160
1161                 { &hf_svhdx_tunnel_disk_info_virtual_disk_id,
1162                   { "VirtualDiskId", "rsvd.svhdx_disk_info_virtual_disk_id", FT_GUID, BASE_NONE,
1163                     NULL, 0, NULL, HFILL }},
1164
1165                 { &hf_svhdx_tunnel_validate_disk_reserved,
1166                   { "Reserved", "rsvd.svhdx_tunnel_validate_disk_reserved", FT_BYTES, BASE_NONE,
1167                     NULL, 0, NULL, HFILL }},
1168
1169                 { &hf_svhdx_tunnel_validate_disk_is_valid_disk,
1170                   { "IsValidDisk", "rsvd.svhdx_validate_disk_is_valid_disk", FT_BYTES, BASE_NONE,
1171                     NULL, 0, NULL, HFILL }},
1172
1173                 { &hf_svhdx_tunnel_srb_status_status_key,
1174                   { "StatusKey", "rsvd.svhdx_srb_status_key", FT_UINT8, BASE_DEC,
1175                     NULL, 0, NULL, HFILL }},
1176
1177                 { &hf_svhdx_tunnel_srb_status_reserved,
1178                   { "Reserved", "rsvd.svhdx_srb_status_reserved", FT_BYTES, BASE_NONE,
1179                     NULL, 0, NULL, HFILL }},
1180
1181                 { &hf_svhdx_tunnel_srb_status_sense_info_auto_generated,
1182                   { "SenseInfoAutoGenerated", "rsvd.svhdx_sense_info_auto_generated", FT_UINT8, BASE_HEX,
1183                     VALS(rsvd_sense_info_vals), 0x80, NULL, HFILL }},
1184
1185                 { &hf_svhdx_tunnel_srb_status_srb_status,
1186                   { "SrbStatus", "rsvd.svhdx_srb_status_srb_status", FT_UINT8, BASE_HEX,
1187                     NULL, 0x7f, NULL, HFILL }},
1188
1189                 { &hf_svhdx_tunnel_srb_status_scsi_status,
1190                   { "SrbStatus", "rsvd.svhdx_srb_status_scsi_status", FT_UINT8, BASE_DEC,
1191                     NULL, 0, NULL, HFILL }},
1192
1193                 { &hf_svhdx_tunnel_srb_status_sense_info_ex_length,
1194                   { "SenseInfoExLength", "rsvd.svhdx_srb_status_sense_info_ex_length", FT_UINT8, BASE_DEC,
1195                     NULL, 0, NULL, HFILL }},
1196
1197                 { &hf_svhdx_tunnel_srb_status_sense_data_ex,
1198                   { "Reserved", "rsvd.svhdx_srb_status_sense_data_ex", FT_BYTES, BASE_NONE,
1199                     NULL, 0, NULL, HFILL }},
1200
1201                 { &hf_svhdx_tunnel_safe_virtual_size,
1202                   { "SafeVirtualSize", "rsvd.svhdx_safe_size", FT_UINT64, BASE_DEC,
1203                     NULL, 0, NULL, HFILL }},
1204
1205                 { &hf_svhdx_tunnel_transaction_id,
1206                   { "TransactionId", "rsvd.svhdx_meta_operation.transaction_id", FT_GUID, BASE_NONE,
1207                     NULL, 0, NULL, HFILL }},
1208
1209                 { &hf_svhdx_tunnel_meta_operation_type,
1210                   { "OperationType", "rsvd.svhdx_meta_operation.type", FT_UINT32, BASE_HEX,
1211                     VALS(rsvd_meta_operation_type_vals), 0, "Type of meta-operation", HFILL }},
1212
1213                 { &hf_svhdx_tunnel_padding,
1214                   { "Padding", "rsvd.svhdx_padding", FT_UINT32, BASE_DEC,
1215                     NULL, 0, NULL, HFILL }},
1216
1217                 { &hf_svhdx_tunnel_resize_new_size,
1218                   { "NewSize", "rsvd.svhdx_meta_operation.new_size", FT_UINT64, BASE_DEC,
1219                     NULL, 0, NULL, HFILL }},
1220
1221                 { &hf_svhdx_tunnel_resize_expand_only_flag,
1222                   { "ExpandOnly", "rsvd.svhdx_meta_operation.expand_only", FT_BOOLEAN, BASE_NONE,
1223                     NULL, 0, "Indicates that shared virtual disk size can only expand", HFILL }},
1224
1225                 { &hf_svhdx_tunnel_resize_allow_unsafe_virt_size_flag,
1226                   { "AllowUnsafeVirtualSize", "rsvd.svhdx_meta_operation.allow_unsafe_virt_size", FT_BOOLEAN, BASE_NONE,
1227                     NULL, 0, "Indicates that the shared virtual disk size can be less than the data it currently contains", HFILL }},
1228
1229                 { &hf_svhdx_tunnel_resize_shrink_to_minimum_safe_size_flag,
1230                   { "ShrinkToMinimumSafeSize", "rsvd.svhdx_meta_operation.shrink_to_minimum_safe_size", FT_BOOLEAN, BASE_NONE,
1231                     NULL, 0, "Indicates that the shared virtual disk size can be shrunk to the data it currently contains", HFILL }},
1232
1233                 { &hf_svhdx_tunnel_meta_operation_start_reserved,
1234                   { "Reserved", "rsvd.svhdx_meta_operation.reserved", FT_UINT8, BASE_DEC,
1235                     NULL, 0, NULL, HFILL }},
1236
1237                 { &hf_svhdx_tunnel_snapshot_type,
1238                   { "SnapshotType", "rsvd.svhdx_snapshot_type", FT_UINT32, BASE_HEX,
1239                     VALS(svhdx_snapshot_type_vals), 0, "Type of snapshot", HFILL }},
1240
1241                 { &hf_svhdx_tunnel_snapshot_id,
1242                   { "SnapshotId", "rsvd.svhdx_snapshot_id", FT_GUID, BASE_NONE,
1243                     NULL, 0, NULL, HFILL }},
1244
1245                 { &hf_svhdx_tunnel_create_snapshot_flags,
1246                   { "Flags", "rsvd.svhdx_meta_operation.create_snapshot_flags", FT_UINT32, BASE_HEX,
1247                     NULL, 0, NULL, HFILL }},
1248
1249                 { &hf_svhdx_tunnel_create_snapshot_flag_enable_change_tracking,
1250                   { "SVHDX_SNAPSHOT_DISK_FLAG_ENABLE_CHANGE_TRACKING", "rsvd.svhdx_meta_operation.create_snapshot_flag_enable_change_tracking", FT_BOOLEAN, 32,
1251                     NULL, SVHDX_SNAPSHOT_DISK_FLAG_ENABLE_CHANGE_TRACKING, "Change tracking to be enabled when snapshot is taken", HFILL }},
1252
1253                 { &hf_svhdx_tunnel_create_snapshot_stage1,
1254                   { "Stage1", "rsvd.svhdx_meta_operation.create_snapshot_stage1", FT_UINT32, BASE_HEX,
1255                     VALS(svhdx_snapshot_stage_vals), 0, "The first stage", HFILL }},
1256
1257                 { &hf_svhdx_tunnel_create_snapshot_stage2,
1258                   { "Stage2", "rsvd.svhdx_meta_operation.create_snapshot_stage2", FT_UINT32, BASE_HEX,
1259                     VALS(svhdx_snapshot_stage_vals), 0, "The second stage", HFILL }},
1260
1261                 { &hf_svhdx_tunnel_create_snapshot_stage3,
1262                   { "Stage3", "rsvd.svhdx_meta_operation.create_snapshot_stage3", FT_UINT32, BASE_HEX,
1263                     VALS(svhdx_snapshot_stage_vals), 0, "The third stage", HFILL }},
1264
1265                 { &hf_svhdx_tunnel_create_snapshot_stage4,
1266                   { "Stage4", "rsvd.svhdx_meta_operation.create_snapshot_stage4", FT_UINT32, BASE_HEX,
1267                     VALS(svhdx_snapshot_stage_vals), 0, "The fourth stage", HFILL }},
1268
1269                 { &hf_svhdx_tunnel_create_snapshot_stage5,
1270                   { "Stage5", "rsvd.svhdx_meta_operation.create_snapshot_stage5", FT_UINT32, BASE_HEX,
1271                     VALS(svhdx_snapshot_stage_vals), 0, "The fifth stage", HFILL }},
1272
1273                 { &hf_svhdx_tunnel_create_snapshot_stage6,
1274                   { "Stage6", "rsvd.svhdx_meta_operation.create_snapshot_stage6", FT_UINT32, BASE_HEX,
1275                     VALS(svhdx_snapshot_stage_vals), 0, "The sixth stage", HFILL }},
1276
1277                 { &hf_svhdx_tunnel_create_snapshot_parameters_payload_size,
1278                   { "ParametersPayloadSize", "rsvd.svhdx_meta_operation.create_snapshot_params_payload_size", FT_UINT32, BASE_DEC,
1279                     NULL, 0, NULL, HFILL }},
1280
1281                 { &hf_svhdx_tunnel_convert_dst_vhdset_name_len,
1282                   { "DestinationVhdSetNameLength", "rsvd.svhdx_meta_operation.dst_vhdset_name_len", FT_UINT32, BASE_DEC,
1283                     NULL, 0, NULL, HFILL }},
1284
1285                 { &hf_svhdx_tunnel_convert_dst_vhdset_name,
1286                   { "DestinationVhdSetName", "rsvd.svhdx_meta_operation.dst_vhdset_name", FT_STRING, BASE_NONE,
1287                     NULL, 0, "Name for the new VHD set be created", HFILL }},
1288
1289                 { &hf_svhdx_tunnel_delete_snapshot_persist_reference,
1290                   { "PersistReference", "rsvd.svhdx_delete_snapshot_persist_reference", FT_BOOLEAN, BASE_NONE,
1291                     NULL, 0, "Indicate if the snapshot needs to be persisted", HFILL }},
1292
1293                 { &hf_svhdx_tunnel_meta_op_query_progress_current_progress,
1294                   { "CurrentProgressValue", "rsvd.svhdx_query_progress.current_progress", FT_UINT64, BASE_DEC,
1295                     NULL, 0, NULL, HFILL }},
1296
1297                 { &hf_svhdx_tunnel_meta_op_query_progress_complete_value,
1298                   { "CompleteValue", "rsvd.svhdx_query_progress.complete_value", FT_UINT64, BASE_DEC,
1299                     NULL, 0, NULL, HFILL }},
1300
1301                 { &hf_svhdx_tunnel_vhdset_information_type,
1302                   { "VHDSetInformationType", "rsvd.svhdx_vhdset_information_type", FT_UINT32, BASE_HEX,
1303                     VALS(svhdx_vhdset_information_type_vals), 0, "The information type requested", HFILL }},
1304
1305                 { &hf_svhdx_tunnel_vhdset_snapshot_creation_time,
1306                   { "SnapshotCreationTime", "rsvd.svhdx_vhdset_snapshot_creation_time", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL,
1307                     NULL, 0, "Time when this object was created", HFILL }},
1308
1309                 { &hf_svhdx_tunnel_vhdset_is_valid_snapshot,
1310                   { "IsValidSnapshot", "rsvd.svhdx_vhdset_is_valid_snapshot", FT_BOOLEAN, BASE_NONE,
1311                     NULL, 0, "Set to 1 when the snapshot is valid", HFILL }},
1312
1313                 { &hf_svhdx_tunnel_vhdset_parent_snapshot_id,
1314                   { "ParentSnapshotId", "rsvd.svhdx_vhdxset_parent_snapshot_id", FT_GUID, BASE_NONE,
1315                     NULL, 0, NULL, HFILL }},
1316
1317                 { &hf_svhdx_tunnel_vhdset_log_file_id,
1318                   { "LogFileId", "rsvd.svhdx_vhdxset_log_file_id", FT_GUID, BASE_NONE,
1319                     NULL, 0, NULL, HFILL }}
1320     };
1321
1322     static int *ett[] = {
1323         &ett_rsvd,
1324         &ett_svhdx_tunnel_op_header,
1325         &ett_svhdx_tunnel_scsi_request,
1326         &ett_rsvd_create_snapshot_flags
1327     };
1328
1329     proto_rsvd = proto_register_protocol("Remote Shared Virtual Disk",
1330             "RSVD", "rsvd");
1331
1332     register_dissector("rsvd", dissect_rsvd, proto_rsvd);
1333     proto_register_field_array(proto_rsvd, hf, array_length(hf));
1334     proto_register_subtree_array(ett, array_length(ett));
1335 }
1336
1337 /*
1338  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
1339  *
1340  * Local variables:
1341  * c-basic-offset: 4
1342  * tab-width: 8
1343  * indent-tabs-mode: nil
1344  * End:
1345  *
1346  * vi: set shiftwidth=4 tabstop=8 expandtab:
1347  * :indentSize=4:tabSize=8:noTabs=true:
1348  */